Rust Programming Language RustRush 2018, 24 Dec 2018

Previous Meeting

⏯

youtube image

►

From YouTube: Keynote. Ashley Williams

Description

Slides: https://ashleygwilliams.github.io/rustrush-2018/#1

Ashley is Rust Core Team Member, crates.io Team Lead and Rust Community Team Lead. She's the director or Increasing Rust's Reach Project, RustBridge Lead Instructor, and a member of Rust/WebAssembly Working Group. Ashley previously was Registry Engineer at npm, and on Node.js Board of Directors. She's also Community Comittee Founder, TC-39 Invited Expert and NodeTogether Founder and Lead Instructor.

A

As I was introduced, my name is Ashley Williams and I'm here, to give you a very detailed titled talk keynote right, so we're probably wondering like alright. What is this talk about and I have, to be honest, I also kind of asked. My same the same question to myself: I was like alright I'm, giving this keynote.

A

What the heck should I talk about, and so I was thinking about it for a while I've, given all different types of talks and I decided, the talk should be about maybe something controversial right, so I'm going to get y'all going, and so how about this? Do we recognize this? How many people have strong feelings about this yeah? Okay? So actually we're not gonna specifically talk about the website, but instead, if you can imagine the you know on those crime shows when they're like enhance right.

A

So if we enhance on this image a little, this gif is too long, but we're enhancing here. The part that I kind of want to focus on is a theme for this talk. Is this so you'll note that when the new website launched there was a new slogan for rust and I bet? There were also strong feelings about that.

A

In fact, I know there were and you'll notice that our slogan has moved from this original one, but I'd like to talk a little bit about this one, and so the slogan was the programming language that empowers everyone to become a systems programmer now a lot of people. Some of this I've resonated with them for some people it didn't resonate, but I am really excited about this word in power, and so obviously it's not a good talk. Unless I, you know, do a little research, so I obviously went to an online dictionary.

A

A super super academic piece of resource there and so empower means to equip or supply with an ability to enable and fundamentally I, think empowering is one of the characteristics of rust. That really drew me to it again. Rust goal isn't just to be an awesome piece of tech which it happens to be, but its goal is to get lots of people to use really powerful tech and that's a completely different problem domain than a lot of technologies really address and so I understand we are in Russia and so I was like.

A

Oh I'm, gonna be defining words. I should look up how to say the word empowering in Russian and I I appreciated that they have like a pronunciation guide there, but um I'm sorry I tried in my room but I. It sounded terrible and it probably would sound offensive I'm, so bad at saying it but anyways. This is the word. Maybe this is like a totally wrong. Translation to I have no idea, but I did try so I apologize if I speak too fast.

A

I really wish I could speak Russian whenever I come to Russia I, like start seeing Cyrillic and I think that I know how to like understand it, and it's just totally not true I'm, not good at it, but it is very cool all right. So, instead of using a definition and words where languages make things complicated, I like to use some rather outdated, American culture. So does anybody recognize what show this gif is from? No all right?

A

So it's an old children's cartoon from the United States called Captain Planet, and the idea of Captain Planet is that there's all these different kind of elements, and then they come together and when they all come together, they form a like environment, superhero that fights pollution.

A

It's an interesting show, but I really like it, because I think is an excellent metaphor for what rust is so I think rust is Captain Planet, and so the idea behind this is that we have a lot of things coming together to create something awesome. And so this is that example of all the elements coming together. They have rings that have powers, but rust is just like this. So rust is trying to empower everyone to be a systems developer.

A

But who is everyone and everyone is a whole ton of people and if you've ever been on an RFC thread, you'll probably have met some of these characters, so we have like diehard like I. Do rust?

A

I only do rust people, and then we definitely have a whole bunch of like C and C++ developers and then every once in a while, particularly in stuff I work in there's, JavaScript people, and then you know throw in some academics there, and then we have some people who are brand-new developers coming in to rust, and all of these people come together to form what I think makes the rust community, particularly special.

A

The fact that we have all of these diverse sets of groups coming together allows us to actually consider a lot of different perspectives that many programming language communities, don't don't have, and so I actually came up with this meme when I gave the rust cough keynote, which is here, and if you remember that theme of enhance, if you enhance on this image, you'll see I, have a glaring misspelling, which I was very disappointed to discover because a lot of people tweeted it but fundamentally I want us to be thinking about this idea of empowering and this idea of bringing a lot of disparate groups that have a ton of different types of perspective together to create cool technologies.

A

So again we were talking about this slogan and yes, people had feelings about the slogan. In fact, people had a lot of feelings, and you should note that this is actually kind of low for a controversial issue in rust. So bless only eighty-five comments before we closed it.

A

Well, one of the things that I think is interesting. That I do want to mention. Is a lot of people objected to this word systems? Programming the reason I, like the slogan saying empowering everyone to become a systems programmer, is often systems. Programming feels like something that's not accessible to everyone. It's like, okay, like maybe I, can write some JavaScript on the front end, which notably, is very difficult and actually sometimes I- think harder than OS dev.

A

But a lot of people think that it's just kind of a type of programming- that's not accessible to them, and they have good reason to believe that, because has anyone ever been to this website, this is the OS dev, wiki and so operating systems is a type of systems development, and this is a page from that. Wiki called required knowledge. I'll just read a little bit to you, so they say if you think you can skip this, it's probably just for you, so you know they're already getting a little spicy, but they say.

A

Reading and OS is not a beginner's task.

A

In fact, reading an OS is usually considered the most difficult programming ask and they move on to talk about the things that you absolutely must be able to do in order to write an operating system like be intimately familiar with hexadecimal I, don't know what being intimately familiar with hexadecimal means, but again there's a lot of the things in here that they're trying to get keep or to keep people away from trying to experiment in systems programming, and so one of the reasons I liked, including systems programming in the rest slogan, was to try and say, hey a lot of people think this is scary and it's rusts goal to make it not scary, which is to say, there's a lot of people out in the world who aren't yet doing systems programming, but we think they should.

A

That being said, the word systems programming has a bunch of negative connotations and stuff like this man. I do not like it. I don't like this at all, so we ended up removing it. But again, this idea of empowerment and being able to get people to do different types of programming that they didn't do before is something that I think is really awesome. So I give lots of talks and I spend a lot of time.

A

Often talking about the people side of things, I do a lot of telling and not a lot of showing, and so when I thought about this talk. I was like hmm what do I want to do and I so rarely get to actually give like a technical technical talk. That I was like today, I'm gonna talk about empowering technologies instead of telling you about what makes the technology empowering I'm just gonna show you, and so I am gonna.

A

Talk to you today about wisdom or webassembly and in particular a really awesome technology that I've been working on this year called wisdom Benjen with the rust wisdom working group. So if you are not familiar, webassembly is often abbreviated as wisdom or wasum, depending on who you are. But my favorite interpretation is there. Is this American commercial while back where people go what's up, and so now the call for webassembly is weather, and then you know you call back welcome it's very nerdy, but I'm super into it.

A

ah So, as I said, my name is Ashley Williams I'm known as a g-dubs on Twitter. If you follow me, I'm sorry, I am on the rust core team. I am on the as a working group. I leave the crates IOT. My leave the community I'm doing a lot of stuff in rust. So if you have a question, come talk to me I'd, probably at least know who you should talk to. If it's not me, but today, I'm gonna focus on my work in the rust wasm working group.

A

This is our snazzy logo which took tons of iteration because you know for systems programmers we care a lot about design which is cool I'm into it. ah So this is the repository for the tool, Wesen binder and just to get a sense of the room. How many people here have written something that compiles to or actually written webassembly?

A

It's like all right cool, all right. How many people have used? Wasn't binding? Okay? Well, that's really interesting. I know we got a couple people from a couple companies here that use web assemblies. So that's cool.

A

This talk is definitely aimed for people who don't super know what web assembly is, but by the end, we're gonna get to some real nitty-gritty cool static analysis stuff. So, let's get to it so hilariously for a tool. That's supposed to be empowering and helping people the term wasm bind gen sounds completely obscure. So when I was talking about writing this talk a little while ago, my friend was like wesam bind.

A

Gen sounds like a village in germany and in particular it sounds like it should be a resort, and so she was like oh yeah, I just got back from Wesen binding near baden-baden in the Scots vault, so I know we're in Russia here, but also Wesen binding is a really kind of strange word.

A

So the first step in the rus community actually has several of these binding tools, but buying gen can be understood as short for bindings generator, which is an expansion that doesn't really tell you all that much more about it, but the way I would kind of describe it. Is it generates code that helps separate types of code, work together and that's still pretty vague, but you know, building bridges is hard.

A

Let's have computers do it fundamentally, a binding is going to be generating a ton of boilerplate code, that's needed to get like two different programming languages to work together, potentially, and so why I write a ton of boilerplate when we have a beautiful language, that's incredibly good at gender reading code. So these binding tools are pretty common in the rust community, there's several of them, but obviously we'll talk about the wasm one today, so Wesson bind gen, describes itself as facilitating high-level interactions between wasm modules and JavaScript.

A

So in this talk we'll talk about what the heck. That means why we want to do this and how it is that the binding tool itself is able to perform this all right. So again, what wesson binding does we'll go through an overview briefly of what web assembly is, we'll talk about, developer workflow go through some features and then we'll figure out some of the nitty-gritty inside wesson binding, is a fascinating tool and I could spend a whole talk talking about just the internals of it. But that is not this talk.

A

They'll come find me later. If you'd like to talk about it. Alright, so let's talk first about what Wesson bind gen does so fundamentally at its core wesam bind gen is going to do two things for you.

A

The first thing it will do is create a wrapper, j/s module for your wasm code and that's because currently browsers are not able to actually load wisdom directly and then it's going to generate bindings for your j/s to communicate with your wasm code and if that doesn't totally make sense, don't worry because that's what we're about to dive deeper into so one thing that I will mention is that wesam budgin is an unusual bind gen if you're used to other bind gens this one's a little bit stranger, and that's because it generates bindings for two things to communicate, but neither of those things is actually rust.

A

We're actually going to be generating javascript, which is interesting. If you are the person who thinks that web assembly is going to kill JavaScript. This talk is for you because it's not going to yeah. So let's talk about why it generates JavaScript. So why do we have wasn't punching so in order to understand the reason why somebody didn't exist? We have to understand some fundamental things about web assembly and since a bunch of people in this audience are here, this might be a little light for you. But we'll go quick.

A

So fundamentally, wasm is a binary instruction format for a stack based virtual machine. As you'll note, it was a binary action format, people like to say webassembly, neither web nor assembly. So it's kind of a misleading name, but we can fundamentally understand it as an incredibly low-level language that is native to the browser.

A

And so, if designed is a portable target for compilation- and so here we say high level languages like C, C++ and rest, which is funny because we often think of those as low-level, and so you could enable a deployment on the web for a client development, but there's also puns with people using web assembly on the server and a lot of very interesting work on wasm, independent runtimes, which is outside the scope of this talk.

A

But if you are interested in, like you know, running wasm on the edge for a CDN or something please come talk to me because that stuff super exciting all right. So what does wasm look like? It looks like this. What assembly has a ton of different formats, but some of them are human readable. So you can see up at the top. That's the s expression format for web assembly. Whenever I show this I like to say for anyone out there that wanted Lisp to win, maybe it did cuz.

A

It looks like Lisp, but you can also see there's a bunch of pretty unhuman readable sections, which is the underlying web assembly. So why would anybody want to use assembly a web assembly? Everyone uses assembly, and so there's a couple of things so first we'd like to say that it's size and load time fishing as a binary format and that's sort of true. It's certainly lower level, it's faster.

A

If it can take advantage of some of the native hardware as rust developers, we may be familiar with the fact that rust tends to produce slightly larger binaries and sometimes we'd want, and that's an active piece of development right now and web assembly for rust, which is very interesting. A nice thing about it, particularly on the web, is that it's a memory, safe sandbox, which is particularly awesome and the most important part, is that it's part of the open web standards. So you may be familiar with something like pinochle from Google or Adobe Flash.

A

Anyone think of like why you would want to use Adobe Flash, it's really similar to why you would want to use webassembly, except instead of having to like download a really shady looking installer. This is just part of the open web standard and something that browsers support by default, which is super cool. So why would you want to use rust in particular to compile to web assembly like any assembly language? You can target web assembly with many different languages, so one of the biggest reasons that rust is a really excellent choice.

A

Is that rust does not have a runtime here. I say rust has no garbage collection, but it's not really true. We have static garbage collection, but the big thing to note is that all of that stuff is not actually happening at runtime. If you wanted to take a language like JavaScript or maybe something like go and compile it to web assembly, what you'd have to do is also compile your runtime to web assembly and include it in the bundle, and so it's totally possible to target web assembly from a huge variety of languages.

A

But when you have to include an a runtime or an interpreter, your bundle size is going to get pretty large and if one of the benefits of using web assembly is to have a small binary having to add a whole runtime to that, binary is kind of losing that point. So rust is particularly nice because it fundamentally doesn't have that runtime overhead, and so it's going to produce a smaller binary than something like go, which is going to have to include that wrong time. And then beyond that whole runtime element.

A

Russ, is very awesome and again as a low-level language. It focuses on the empowering element, which is to say rust, is tends to be more approachable than something like C or C++. And to that end, if you're a JavaScript developer, looking to do some web assembly reaching for rust, could be potentially more welcoming than trying to target one of those other languages all right. So at the beginning of last year, when we were setting the rust 2018 roadmap, there was a bunch of hype about web assembly, and web assembly is generating a ton of hype.

A

Now and I have to say, I'm personally nervous, I want to make sure that technology lives up to the hype, because there's a lot of people quite excited about it right now, but one of the reasons I'm particularly excited about it is this graph. So people who know my background will know that I used to work at M p.m. and so I see people a couple of people cringed here going.

A

So this is the module accounts website, which is a website that keeps track of the number of packages on package managers for many different types of communities and languages, and here I've just reduced it to NPM and crates I/o, and so you can see NPM kind of shooting up like that and crates a oh I mean the fact that you can even see it going up in comparison to the NPM growth chart is actually really awesome like good job y'all we're doing it because NPM has really just taken off with stuff.

A

However, the awesome thing about webassembly is what, if rust as a language that can target web assembly, could take advantage of this obviously huge exponential growth of the NPM and JavaScript ecosystem, which is to say if we can use rust to target web assembly and create packages that could be distributed on NPM. Look at the large number of you know. People and packages that we could interact with like this is a huge growth opportunity for us and I.

A

Think that's one of the most awesome parts about web assembly, so web assembly comes with some of its own difficulties, though, like it's, a very awesome, powerful language, open standards- hopefully at this point you're at least vaguely sold on the idea that it's interesting but there's some serious downsides. So one of the biggest ones is that wesen modules can only call our export functions which deal exclusively with number types, and so you might be sitting there going mmm well, you know all programming can be reduced to numbers. It's totally true and yeah.

A

I guess that's true like it is complete that you know. Webassembly can only express a program with numbers, but I'm not interested in doing that like web development is something that I'd like to say is fancy string, concatenation and well. I totally understand that strings can be expressed as a number my interest in expressing strings as a number when I'm trying to like write some HTML is exactly zero. I want my string type ID want to be trying to convert everything to numbers all the time.

A

Strings are already difficult enough as it is, and as rust developers. You probably know that so having to take the strings and then parm into numbers and all over again would be completely unpleasant, so enter wasm Ferris, and this is really the driving motivation of wesen bind join, and so the goal of wesen bindin is to enhance this ABI of wesen modules with richer types, which is to say, I'd really like to program with something more than numbers.

A

So if you aren't familiar with that word ABI, it stands for application, binary interface, and so it's just fundamentally the interface between two binary program modules. One of them is often a library and the other, an operating system or a library or operating system and others something that's being run by a user, and so the web is a really interesting platform, insofar as it never really had this base layer.

A

If we look at stuff like Linux or maybe even the JVM there's, an understanding of an avi and usually the ABI is one of the first things when platforms come out to be developed, but the web is kind of fascinating in that it developed kind of out of order.

A

So we got all of the other higher-level bits like languages and tooling, and libraries and ecosystem and now kind of like a little late right now, we're throwing in that bottom layer and so that's kind of an interesting development to see that it's kind of happening out of order. So lazon is the ABI of the web. But, as I've said you know it's just not complete yet so we only have numbers and there's also a fair number of other things missing.

A

There's lots of proposals if you're interested I'm having to talk about them, but for the sake of getting through this, we're not going to dive too deep into that. But so the dream here would be something like this. Where we could take rust, we could use cargo and we could build our web assembly and it would be easily consumable from either a browser or no js'.

A

That would be the dream, but it turns out that currently we need a little bit more to get this going, and so why isn't buying jan and a couple of other tools, I'm going to talk to you about or what is going to make this better. So one of the big reasons this is a problem is that if you have a website in this day and age, you likely also have some JavaScript and I.

A

Imagine there's people out here who think javascript is terrible and like bless, but like JavaScript is not going away and the web runs in JavaScript, and so in order to make web assembly a viable technology for using in the browser or node, we need to make it be able to interact with JavaScript. This is a number one important thing.

A

So again, if you thought web assembly was trying to kill JavaScript, it turns out that one of the most important things for web assembly to be successful is for it to actually be able to talk to JavaScript, because JavaScript is such a runaway success that, even if you desperately wish for it to die, it's not going to at least not anytime, soon likely, not in any of our lifetimes. So how do we solve this problem?

A

As I said, web assembly really only understands numbers and, if you've programmed in JavaScript you're aware that they have strings object, even classes, and so how do we get rusts to compile to web assembly and then make that web assembly able to talk to the JavaScript without having to constantly shoehorn things into vex of numbers, which is an unpleasant task? And so fundamentally the tool gene that we have is going to do something like this. So as I said before, what we have is we write our rest.

A

We compile it using the wasm, 32 unknown unknown target and we're not yet done so once we've done that we're going to use tools called lesson pack and wisdom bind gen to generate a bunch of JavaScript and generating that javascript is going to allow us to be able to use our web assembly and also have our web assembly talk to other JavaScript. And so what you can see in this picture is that we have a little web assembly kind of surrounded by a JavaScript. That's the module wrapper and then we're gonna jump into this.

A

But the second J's file, that's generated is going to be a file that is going to allow talking to the rich types in JavaScript and then have boilerplate that will automatically convert those rich j/s types into the types that web assembly understands. Fundamentally, all of that conversion boilerplate being generated for you using these tools all right. So why the heck would you to do this like? As far as like architecture, documents go like this looks kind of complicated right, so there's a lot of real good benefits for this first off productivity.

A

So hmm I would like to write rust to generate webassembly. Maybe I should write web assembly from scratch. It's certainly possible to write assembly from scratch. I've done it before it's pretty fun, but it's not terribly maintainable code. I. Remember at one of my first, the very first rust fest that happened.

A

I gave a presentation on a teaching operating system, I work on, and they put me right after lunch and I was like okay, I'm gonna hand code, some live assembly to hand code assembly live to like wake everybody up and, of course, I changed something and my vector and didn't update the length and got one of those really epic beautiful error messages that assembly gives you. So that's not really fun. Russ gives great error messages.

A

Additionally, you have this idea of maintainability, so javascript is actually fast, and if you want to fight me with me about that later, that's fine. We can go do that in the hallway, but the engines that are processing javascript in the browsers are actually incredibly great. The trick is is order to write fast JavaScript, you have to be a magician or a wizard. You have to know all of these really fancy optimizations that, like something like v8 is gonna. Do and you're gonna have to write code. That looks bonkers like absolutely ridiculous.

A

Looking JavaScript, whereas writing rust, fast, even rust, that compiles to web assembly. You can very pretty idiomatic looking code, and that makes things significantly more maintainable and then finally, one of the awesome things about restauranteurs web assembly and webassembly in general is the accessibility angle, so I think rust is certainly more approachable than C or C++. That is my opinion.

A

But, additionally, if we just take a look at it from the web assembly technology side with smaller bundles and more efficient execution web assembly codes going to be able to run on better devices, we had their web somebody working group this year and it's fascinating. How much overlap there was between the web assembly working group and the embedded working group, because we have very similar constraints and so all the benefits that you have and the things that you need from something like an embedded ecosystem like small binaries memory profile.

A

All those things are, but whether somebody's also gonna help benefit from alright. So in theory, I have sold you on wanting to use webassembly, maybe I haven't, but assuming that I have sold you on this.

A

Let's talk about how you can do this today, so despite the fact that webassembly as a technology as a spec is still incredibly new and young, we have done a ton of work this year to build a bunch of tools to make using rust and webassembly like possible and vaguely enjoyable, and so I'd like to go through a bunch of those tools for you now so I like to say that it's magic I know the idea of magic in programming is some people like it.

A

Some people don't, but one of the things worth noting is that as we target this rust, webassembly developer workflow we're focused on rust developers, but we also want j/s developers because remember we want more people to become rust developers. We want to empower folks, and so creating these workflows is both focused on rust, folks, but also bringing in people who have maybe not dealt with a compiled language before alright. So how many people love their developer? Workflow Oh me I, don't know if you can understand me or you're not participating all right.

A

We can cope one person, that's good, we're rust developers. Car goes pretty cool. The dev tools team is going to have to talk to the lot of you because apparently are very disappointed in the developer workflow.

A

But so, although jeaious developers have fascinating workflow problems and I think developer, workflow and developer tools is really really interesting and that's why I've really enjoyed working on these projects. So what we want is for you to feel a little bit more like this, with your developer, workflow, really coordinated, smooth having a good time and not crying at your laptop, so I. Look like that.

A

A lot so, and so one of our goals with the developer tools for this was that wisdom is not trying to replace JavaScript, which is to say all of the workflows that we create for rust and webassembly should integrate seamlessly with the workflows that JavaScript developers already have. And let me tell you like, if you don't like your rust developer, workflow, the job is script. Developer. Workflow is all over the place. There's all sorts of bundlers and compilers transpilers tons of stuff to deal with. So at least javascript developers are used to a compile step.

A

They're, usually not in the sense that rust has won all right. So, as I said before, we're not trying to kill JavaScript. Remember almost all of this workflow is about generating and interoperating with JavaScript it's tons of JavaScript here.

A

So our use case when we first started developing these tools was that we want people to use web assembly to just surgically replace hot paths in their JavaScript like potentially, you have some sort of JavaScript where you know JavaScript might not be the right tool for the job, and it's really complicated for front-end developers like the idea of right tool for the job.

A

If you're a friend and developer you're, the idea that you could like choose the right language for the task, wasn't really an option like you have JavaScript and that's what you have that's what you have JavaScript, and so this whole introduction of web assembly means that we can also kind of have to teach a generation of developers how to decide which tasks are good for one language versus the other, and this is actually an incredibly difficult task.

A

There's tons of people excited about web assembly, but what is web assembly good for is still kind of an interesting and open question. So a lot of folks that we've seen who are early adopters of web assembly for this type of use case. I've been primarily using it for parsing, which is a incredibly complicated task and usually very resource-intensive, but this is still a very interesting and open question all right. So one of the examples of this that's currently I believe now.

A

Finally, in production is the source Maps implementation for Mozilla Firefox, and so this was an article for the Mozilla hacks blog that was written by the lead of the rest. President working group, Nick Fitzgerald or Fitz gen, as you may know him on the Internet, and so these are some benchmarks and I know people love benchmarks, but I will be completely honest with you in that it's very early in web assembly days and for much of your experience.

A

Making your web simply go faster than your javascript is actually hard, which is what I mean by Java just faster than you think it is, but there's something very interesting about this graph that I really love and I. Wonder if you all notice it so just to explain. What's going on here since the colors look, a little dull you can see down here. The red is the JavaScript and across we kind of pair it with the web assembly, which is in blue and then the first two are Chrome's second or Firefox.

A

Second, two are Safari, so people might originally look at this graph and go. Oh. The web assembly is faster. That's very interesting. I love that I love going fast, but particularly as an ops developer. When I look at this I see the vert of something very different, which is take a look at the standard deviations of these timings.

A

When you look at the JavaScript one, you can see that it has extremely large standard deviations, which is it spread pretty far, and why would that be the case? Well, that's the case largely because of some fun thing called garbage collection. I mean there's often other things involved in that as well, but garbage collection is certainly one of them, and so, when we take a look at the web assembly here, the reason I love web assembly is because it is predictable.

A

It's cool that it's fast, but it turns out that making it fast is hard. It's resource usage, so is incredibly predictable and that's that type of reliability is something that I think is one of the better cells. So you hear people say web assemblies fast, that's cool, but you know someone's talking about the right thing. We're talk more about the resource. Predictability, all right, so ok, I told you I was gonna.

A

Tell you how to do this and I've still just kept talking about how cool web assembly is sorry about that, let's get into the house all right. So this is an amazing code cartoon from a artist and engineer named Lynn, Clark she's super awesome and you should read her blog posts, but funnily, this is the workflow that you're gonna do so you're gonna compile your code to the web assembly target from rust.

A

Then you are going to run the wasm binding, CLI tool to generate your bindings and then you're able to package it up and deploy its NPM, and then you can consume it from one of the JavaScript bundlers or, alternatively, you can just consume it. Whichever way you want without using a, and so this is the general workflow. So what would the code look like? So this is our hello world. You can see here in your cargo tamil. You have to put a couple of things, but your primary dependency is going to be wasm.

A

Binding, you're gonna quickly see that wasm binding is kind of deceptively actually two tools. It is a library and a CLI tool and we'll talk about how those work in a second.

A

But then you can take a look at your libbed RS here and what you'll see is that you're gonna be using this wisdom, bind gen attribute and that's because we leverage procedural macros to do a bunch of code generation for you, there's code generation at every step of this, but one thing you can see is a lot of what we're doing in web engine is the idea that we have to be able to pull things in from j/s. Then we need to be able to send things out to j/s.

A

This is like a huge input/output machine, and so up here on the top you can see in the X turn block the first one you'll. We write basically a function, signature for what we anticipate will exist in the browser, so this is actually more complicated than you actually have to write. It. We've made it even simpler, but if you want to anticipate that, there's an alert function in your browser, you will write, function, alert and then you will write the type of the thing it takes.

A

Then you can write your rust program and here we're going to be exporting a greet function and that greet function is just gonna call the browser's alert function and it's gonna pass in hello and then your name. So this is a basic kind of hello world. In our system, right now and as I said, it gets super fun.

A

So we don't only have naive examples and I'll but I'm about to dive into a bunch of others, but the steps that I talked about seemed a little complicated like first, you add the target and you compile to the target. You run the bindings, you do all this stuff, you publish the NPM. We realized that having all of these disparate kind of tools to use was kind of a pain in the butt, and so so was born.

A

This tool, called wasm PAC originally was in pack was a tool just to publish to NPM, but it's now become an integrated, build tool where we're gonna be compiling to web assembly. We're gonna run, wasm bind gen for you, so you don't even have to use baizen Benjen and we're going to generate package for you that you could simply use like any other JavaScript package. You could publish it to NPM.

A

You could do all sorts of different things with it, but fundamentally we basically create one of those little web building blocks that anybody who's out there on the web can just use so you can just publish. This is an example. If you go to my NPM profile, you'll see that I have tons of weird garbage packages that are just full of weird example code, but there's tons of these that you can find and the webassembly packages on the NPM registry are growing.

A

So if you wanted to consume one of these packages, I wanted to just show you quickly what that would look like. So if we wanted to consume our hello Essen package that we just generated, we can just add it as a dependency in our package JSON.

A

If you're familiar with how NPM works- and we can just add that right there and then we add it like require it like we would normally or maybe import, and then it will just work so that code we had called that alert function from the browser, and here it is alright. So one of the interesting things about web assembly, because it's such a foundational tool, is that its success is going to be very quiet, because if things work well with web assembly, you shouldn't even have to know that you are using it.

A

And so our goal, at least from the Russell has a working group position, is that we want to find foundational libraries in the NPM ecosystem, where a lot of them are doing like incredibly resource intensive work and like kind of silently replace them with web assembly implementations. So you might be using something like say, react and you'll just keep using react the same way. You always would use it, but slowly bits and pieces of it, maybe like a virtual Dom implementation or something like that will actually be replaced with web assembly.

A

So as somebody who's really excited about the technology, it's an interesting thing to evangelize, because, fundamentally, if we succeed, you shouldn't even know we were there all right. So let's talk a little bit about kind of show you what the end work is and kind of a high-level workflow. What exactly just happened all right, so what we did is we ran this tool called wasman pack, and so what we can see up here is we started with a crate directory and inside that crate directory.

A

We have like kind of what we would expect in there, so we have source, we have a lib, and so, when I run, where as impact builds, what that's gonna do is it's gonna generate a package directory and inside the package directory is all of the things we generated both using cargo build and using wasm binder. So we've got a bunch of actually really interesting things in here.

A

So, as I promised you we're gonna generate a wasm for you and that exists right there, but other things that we have is this hello, Azzam Jas, that's gonna, be all the bindings, so all of the things all of the functions that you had in rust that use rich types that aren't numbers. This is going to have all those conversions for you and then a super-fun thing, because we're coming from a strongly typed language, we're able to generate typescript definitions for you for free, which is pretty red.

A

Even if you don't use typescript lots of ideas, leverage these types files to be able to give you autofill and all sorts of things, and so that's really great.

A

Additionally, we generate a package JSON for you and right now we just copy or read me over, but there is some work in progress about taking your doc comments and being able to take what rust doc would write and add it to your readme for you so that you can have kind of a base API documentation inside your readme, because it turns out in the NPM ecosystem, readme czar, really the docs that people use so just throw everything in there all right. So those are the files that are generated but like what actually happened.

A

This is a very complicated diagram here. So what was impact does, for you is this. First, it's gonna run cargo build target was M unknown unknown, but then what it's going to do- and the trick here is that it turns out that targeting that wisdom, 32 unknown unknown target doesn't give us entirely what we want. There's a bunch of things that are like vaguely associated with, like the host bindings proposal that but building to this isn't going to give you, and so that's why the Wesson bind JNT.

A

Cli tool is going to step in and take the product of cargo and make something better for you. So you using the magic of procedural macros what's gonna happen is wesen. Benjen is going to take a look inside the generated web assembly.

A

It's also gonna, look at your rust and it's going to clean up a bunch of your web assembly and then it is also going to take a look at all of the functions that you've tagged with that resin binder attribute, and it's going to generate the binding functions for you and all of the wrappers that you're going to need, and it's also going to generate that types file for you and I'll. Tell you about how it does that, hopefully very soon.

A

But fundamentally, what you should understand is that you're going to be using this resin binding attribute just to mark all of the interface touch points inside your rust, so, whether you're trying to talk to something that's in JavaScript or, if you're, trying to export something out, so the JavaScript can call it you're, just always going to be tagging your functions, your strokes with that attribute and that's gonna, be how azzam bind you and knows how to generate what it needs to generate for you, and so that's the magic of the wisdom binding CLI.

A

So you use the library to be able to tag with the attribute and then the CLI is going to take a look at that rust code that you wrote and it's going to look for all those attributes and do all of its macro generation stuff for you. Alright. So that's how you can do it, but we're still are entirely clear about what it is you can do and the functionality of wesen Benjen has grown exponentially over the course of this year. It's pretty fantastic. We went from like yeah, you can.

A

You know manually import and export things and do hello world, which is like super not that interesting to let's do some web audio stuff, which is pretty cool. So one of the things that I hear a lot from people, thinking about, like rust, generator web assembly and being able to talk to something like JavaScript, which has prototype, will inheritance but now kind of has classical inheritance is like okay, like there's so much classical inheritance in JavaScript programming.

A

How do I write rust that can like talk to that type of thing, and so there's a fair amount of development this year that focused on being able to allow rust to kind of talk in the language of classical inheritance, which the OO functional debate in rust is its own other thing. But in order to talk to JavaScript, we need to be able to do it, and so you could create a constructor and be able to instantiate a Jas class.

A

Again you just create that extern block and you're gonna write the function, signature and you can decorate it with that attribute and just say: hey. This is the constructor and, as a result, you can now call that Jas constructor from your rust just like this here with shoes. Do so it's a pretty pretty fluid interface and you can do it in the opposite direction, though something that you should see as a theme is calling. The J's from rust is like significantly easier than the J is calling the rust. So here you can see.

A

This is just instantiating a rust class, so we can say: hey we have a struct, we'll give it a new function.

A

It has this method called get contents, and so, if we wanted to be able to do this so here we can see that we're at again decorating with that attribute, so that now we can say, hey I have some love assembly, let's load it and now I can say, get new foo and then call a method on it, which basically means that I taught JavaScript how to treat rust like a classical inheritance language, which is super fun and very interesting.

A

If you are curious about what the memory is doing under all of this, it's fascinating and probably could be the contents of a whole own talk but yeah. So this also works for methods. I won't jump too far into this, but it's also very interesting that we understand class hierarchy if you're someone who's deep in web assembly, you're, probably like the any rough proposal and like we're working on it, but you can fundamentally, like also have those hierarchy trees.

A

The way you want, regardless of if you think those are a good idea or not, it is possible, which I think is very interesting, all right and so yeah.

A

This is something that happened quite recently and it's something that we continue to focus on, because again, it comes back to the idea that, like being able to interrupt with JavaScript and work with JavaScript paradigms is incredibly important for the success of web assembly and so being able to do these, regardless of your feelings about classical inheritance, is super important, alright, so the two most exciting things that I feel like so few people actually know about working in webassembly.

A

Even if you know these technologies are two crates that are part of the web weizen binding tool called jaya, sis and web sites. Just out of curiosity, does anybody here know these two two crates alright? Well, everyone else is going to and it's really cool, because I honestly think they're magical. They really are so J Isis. Both of these fundamentally, our API wrappers, which is to say I, want to write web assembly.

A

I want to write rust that generates into a web assembly and I don't want to have to like write my extern block with, like all of the things like I'm, not interested in defining document window. I, don't want to do all that. I want to be able to use a crate to do that and so J Isis is a crate. That's going to give you all this, you don't have to manually extern any of those things.

A

So one thing that you can see in this example here is: if we bring in the jss crate, oh gosh, I, just scrolled that was terrible. Alright J is this crate, so here you can see like I. Don't want to have to like define what the array type is in JavaScript the jsj s. This crate is just gonna. Do that for me, and so we can see right here. I can just call array, dot new and date, dot date, I guess, dot is colon. Colon now and that's all exported by the jeaious is crate.

A

So I have to remember what those function signatures, look like they're already defined for me, so I can just assume the jsapi inside my rust, which is very cool, but the coolest one is web sis. So web sis is a fascinating tool from several different angles. You can understand it in relationship to J is now the mic is working. The mic is not working. Okay, it's similar to justice in that it's going to take all of the browser API and also make those available for you the same way.

A

The jss makes the jeaious API available to you, and so the coolest thing about this tool is that while it was not entirely perfect, it was possible to mostly mechanic. We generate this entire library using using the web interface definition language. So we all know what specs are right: yeah, yeah, cool specs are awesome, and so there's often a joke, particularly when we talk about web specs or like web specs are written in a type of language that directly compiles to C++ and if you've done any spec work or implementation work.

A

You'll probably be aware that that's super not the case, and it would be really delightful if it were, but it's not at all.

A

So some people were kind of bummed out that it turns out that using English is like not a it's very difficult to be incredibly precise, using English in specs, even if you're incredibly practiced and thoughtful about it. So they were like what if we had a programming language for specs and you feel like if you've done any spec work, you're, probably going oh, no, but a nightmare. It's a lot of extra work, but because these IDL this IDL exists for the web spec.

A

We were able to take that and use that that definition to be able to automatically generate these bindings for you. So that's pretty cool. So it was a pretty painless experience. The vast majority of the manual work was to write tests for it, which is no it's everyone's favorite task, but why am I so hype about web says all right. So this for people who are aware of webassembly one of the biggest things people will go, is well I'm, not ready to use this because wisdom can't access the Dom.

A

If you don't know what the Dom is, it's document object model. It just means like can I grabbed a div, and this is something that I mean is reasonably very important to folks who want to be working on the web, and so shout out your answer. Ken wasm access the Dom, no right!

A

No, but also yes, but no. But yes, the trick is that wisdom in its native sense cannot, but because of web sis you can sort of. So a lot of people are like Oh Adam can't access the Dom I'm done, and so it's true that it can't natively. But what web sistas is it's going to be able to after having generated all that stuff from the web? Idl give you an API for interacting with the web api's. uh That's pretty frigging friendly. So let's take a look at this code here.

A

So first, what you can see is like we have a window. We have document, we have body if you work on the web. These are things that you are used to and then look at this. It's basically jQuery like oh, let's create an element: let's set inner HTML appendchild like again Azzam can't officially access the Dom, but this is us, manipulating the Dom right now from rust. That's gonna compile the web assembly and it works very well.

A

There's definitely work to still be done to like make this as fast as it should be to make it as small of a binary as it should be, and fundamentally we want wisdom to have these abilities natively, but this is possible today- and these are just some very, very like small little things that you can do, but the entire web, sis crate, gives you an immense number of abilities. So just to start like, as I mentioned, all of the Web Audio API is exposed for you, there's also Web USB.

A

That's amazing for people who love doing benchmarks performance thought now. If you want to be doing benchmarks in your rest, web assembly, you can also use fetch, which for people who might not know, is kind of what replaced Ajax requests but HTTP requests and then, if you're, the type of debugger like me, you can use console.log, which is my favorite style of debugging.

A

But these are things that you can do right now, and so, while it absolutely is true, like wasm can exit the dom fundamentally, that is not a blocker right now, particularly for folks who want to use this wiesen by gentle training. This stuff exists and is ready to be used, and it's really exciting.

A

I think the message that wisdom can access the dog kind of went out into the community very quick like quickly and strongly, and so I really want to make sure that I drive the point home that if you want to write rest assembly, that excess is the Dom. You can definitely do that, and you can do it right now and it has a really lovely API. All right so now into some of the nitty-gritty.

A

I could definitely give a talk about how was in bind Jen works and I could do it, and it would probably be like three hours long. It's a fascinating tool, we're always looking for contributors who definitely join in, but we can talk a little bit about a couple of things so classically with tools like this. You know you want to peer into the inside right and sometimes it's not that friendly. So maybe maybe looking at the internals of wesen bindin.

A

Isn't your idea of fun and that's totally okay, you can feel free to zone out at this part if you'd like, but fundamentally we had kind of two design principles with designing wizard by Jen. The first was that we are really es6 modules from this start.

A

There's a real focus on wanting to use that now, of course, the entire tool chain is designed to work with also commonjs, and also a no module situation, but we've really made primary the idea of using this with es6 modules, particularly because of the heavy use of bundlers across the web.

A

It just works out a lot nicer and then, like the last thing, was kind of on this theme of empowering, which is this tool should not get in your way. This tool should just be like an like an oil slick like we just want to get through it. It shouldn't be right there in your face. It should be unobtrusive, and this is part of the reason why we've taken wisdom, bhaijan and kind of subsumed it into as impact like you can use wise and back and Wes impacts.

A

Can you use wisdom, bind Jen under the hood, but you shouldn't have to think about it that much if you've ever used wiesen binding from scratch the CLI tool. You know that there's like 8000 different options and things like that to configure it and you can always dive down and like do that if you want, but fundamentally the vast majority people love good defaults and not configuring. So it was a big deal to say. Okay, let's make all of this dev joy at work, unobtrusive, alright!

A

So in my first version of this talk, what I did is I spent a lot of time talking about the fundamental memory layer and I ran out of time and I gave that talk.

A

So I'm gonna talk about something else, but the real question of how does wasm bind Gen work is this: how do we shoehorn j/s objects into a u32 for wisdom to use basically just like how could we turn everything into a u32 and do it as efficiently as we possibly can, and sometimes it definitely feels like this truck backing into this thing, which is like magical like how'd.

A

It work I'm scared, but the thing I want to talk a little bit about today is the wisdom, benjin macro, so the wesson bündchen macro is pretty interesting and the challenges that we had in trying to figure out how we generate those wrapping binding function, signatures for taking like your rust function and then doing all the all the boiler plates and make sure that you could use a rich type and so what the macro does it's going to generate an executable function, which the point of is to describe the type signature of an import or export?

A

Fundamentally, this whole tool is about these interface liars and we're just jumping in between these interfaces and trying to talk about them, and so we can take a little bit of look at this code right here. So, as you saw in our previous example, in your rust wasm code, you probably have a function. Signature that looks like this. It's probably marked pub, but it doesn't matter, and so we mark that with that attribute- and we have that, and so what gasm bind JNT is going to do is really interesting.

A

But let me tell you a little bit about why so, when we are generating a rust running, wizard bhaijan CLI, we're able to do a fair amount of static analysis. However, because of certain types, the rust compiler is not able to fully know all of the rich type information. At that point like we can't just do static analysis, we're gonna have to compile it. We don't want to do that right now, so we serialized what we can know about the function signatures into JSON, but then because we can't know all that information.

A

Instead, what we do is we actually generate more rust, and this is what the macro does and the rest generates a function that looks like this. This second one here and what that's doing is it's leveraging a trait called described and that described trait is gonna snag. All of that super-rich type information that we need in order to be able to generate that j/s type information that we want to do, but we can't do that just with static analysis.

A

We have to do it by creating these executable functions and then, when we run the wasm bind gen CLI it's going to compile and then execute these functions, and when we execute these functions, that's when we're able to extract that rich type data from our function, signatures in rust, so that we can actually generate that really important joyous type signature stuff in the gif bindings that we generate and so I think that's like a very interesting design element and so I thought that was pretty cool.

A

Now, if I totally lost you and you're like what why types I don't want to that's fine, the best part about wasn't binding is that you don't have to worry about how it works. It just does, but because it's an empowering technology, if you want to know how it works under the hood, you 100% can and I think that that's super awesome. You can learn so much about how rusts the rest, compiler and JavaScript all work by taking a look under the hood and at your generated files.

A

So fundamentally, what I want to say is I hope. This idea of kind of like taking a look at web assembly, the ideas we had for designing the dev tools, make you excited to explore different parts of programming like I, think one of the most fun parts was being like the web developer representative, unlike the rust like web, does suddenly team because we kind of had this perspective, rust and I'm like well. This is how jeaious developers think about it and expanding rust into different areas.

A

I think is really interesting and fascinating, and it taught me a lot about rust and JavaScript in them in the meantime. So, if you are interested in you know, opening that basket and getting scratched by the cat, um you can learn so much about the internal design of wesen Benjen from the wesam binder guide. We have extensive documentation, not on just how do you it, but how it is implemented. So it's super super cool and I would strongly recommend you check that out.

A

I'd also encourage you to get involved, even if we like need more just web developers like if you don't even know rust like we need you so badly. So please get involved in the rust Bassem working group. Additionally, we record all of our open calls, and so, if you want to watch all of us being goofballs, we post all of the videos to YouTube.

A

So you can check those out and hear about our discussions and so yeah, even if you aren't excited about webassembly as rust developers, I want to encourage you to be looking for places where you can develop more technologies within the rust ecosystem that empower people to do stuff, because this is truly the Captain Planet element of rust and with that. Thank you very much.