Jay Phelps - React, Powered by WebAssembly

[Music] [Music] hey everyone alright so today I get the privilege of talking about something that I'm pretty passionate about if you follow me on Twitter you probably already know that super passionate about it because I tweet just so much about it and that's webassembly and just so I have a general idea how many people have actually heard of webassembly before like you may not even know what it is but you've at least heard of it okay cool great so the majority of the room so I think that webassembly is going to change the way that we build and think of what a web app is and in in in the not-too-distant future we may even stop using the word web app when we talk about an application just because it's really going to enable in long term the distinction between a native app in it and a web app to to completely blur and so Who am I I'm I'm Jay Phelps and when I originally was accepted to do this talk and planned it I was actually a software engineer at Netflix but this has actually changed in the last month I went off and did the startup thing with my friend Tracy at a company called this dot and what this dot does is we do support training mentorship software architecture and developer relations and that type of thing which I was doing for the last couple years anyway just more organically and so it just basically was a very natural thing and with this thought I'm gonna be able to do all some more stuff with rxjs which I'm very obsessed with and webassembly as well so if you have any interest in these type of things - feel free to get in touch so let's get started what exactly is web assembly right or aka Wazza more razzle depending on what part of the country you're from it's an efficient low-level byte code for the web that's how they describe it that's how I've usually described because it's a very terse definition but what does that actually mean well let's look at efficient what we mean by efficient is that it's fast to to load into the browser to actually transport over the internet and load into the browser and then it's actually efficient to actually compile and create native code from just-in-time create that that native code and actually run and if you've been following a lot of the industry stuff on JavaScript this is the second part is a really big deal because we've worked really hard on bundle sizes but parse times have become a really big deal you might have a you know one megabyte of JavaScript code and now you've got like maybe fast internet connection so that's not a big deal but the parse time on that JavaScript could be huge it could be more they're gonna be more parse time than actual downloading over the Internet so that's what we didn't buy efficient webassembly aims to be fast to load over the internet and fast to actually parse for the browser the second point of that so let me shoot by the second part of that is that it's a low-level byte code and as JavaScript people we probably have had not a lot of interactions with what what byte code actually means and so what I mean by a byte code is that it's actual binary the instructions the data that you compile down to becomes an actual binary file so this is an example of one of those binary instructions this is a hexadecimal of the add instruction in 32 instruction but you you know the goal of tooling is to to make it so that you don't really need to know all of this stuff if you've ever written things like Java or C sharp things like that where they have byte codes ideally you never have to worry about that and that's just an implementation detail but it is good to know because web assemblies early the next part is that it's a compilation target and what that means is that you mostly won't be writing web assembly by hand and I say mostly just because if you are an early adopter right now chances are you might have to get dirty with some web assembly here and there and my talk is gonna cover some of that just to make things easier on you but it's as a long-term play its intended as basically it's an implementation detail you really don't need to care how web assembly actually works under the hood but let's let's take a look at it at a very simple example this is actually C code or C++ and really it's equivalent and if you've never written C C++ hopefully this isn't too intimidating basically it's JavaScript where there's a type Titian you know so so so hopefully hopefully this is totally okay didn't mean that to be funny but glad it is but with limb assembly this is this you could you compile this C code to this binary data on the right mobile circle back on Mac here in a bit so web assemblies intended to be safe and portable just like JavaScript is and what we mean by that is if you've ever written in C++ or C maybe in college maybe a previous job you know that the languages like that are are just full of possible exploit vectors you know if you over run the stack you might be able to to add executable code and then jump to it and things like that with web assembly you can't do that now it's definitely possible for you to still over run the stack but you won't be able to like a user could insert arbitrary instructions and stuff like that in linear memory but there's no way to actually jump to those in that linear memory it's designed to be sandboxed and if and safe so not only can you not over run that linear memory and get into other segments that you don't this shouldn't belong in but you can't actually jump to an instruction inside some sort of textual literacies me a binary linear memory if you want to do what's called dynamic dispatch those things have to be assigned into a separate function table and that's that's a pretty advanced topic but so it's also designed to be basically a shortcut to your JavaScript engines optimizer that's what Ben Smith who's on the core team describes it as and then that basically means that they get to the browser's got to reuse their existing existing virtual machines that they created for JavaScript which is one of the main reasons that web assembly was even possible to begin with because trying to get all of the browser vendors on board with something is a very difficult task and there's been many false starts in the past there's Azzam Jas and pinochle which is like the chrome side of things so finally they were able to figure out a way where we can create a bytecode for the web that can utilize their existing virtual machine but well when I when I say this shortcut to your JavaScript engines optimizer a lot of people the next question they'll ask is well is this gonna kill JavaScript then like you know are we basically going to always compile in another language and we're gonna go straight to webassembly and never use javascript well the the browser vendors are gonna tell you know that that's that's not that's not the aim and that's true that's not the goal of web assembly javascript has become a much better language in recent years and I really do recommend it for all the majority of people but I will go on and say that maybe it will somewhat decrease or even maybe in the future significantly decrease how many people choose to use javascript so and that's just because it's gonna open up the ability to just have a whole new world of programming languages right now if you've got languages like dart and reason and elm they could pile to JavaScript which isn't ideal because javascript was not intended as a compilation target so your binaries are gonna be larger the compiler the actual browser and the compiler the compiler and the browser is not going to be able to optimize it as well as as a byte code but web assemblies gonna enable that so it's possible that something better will come along maybe reason or elm or you know heaven forbid dart is going to you know become the new standard for the web but that's you know it's less certain and that's really not a stated goal the next question that people are gonna ask is will I actually compile my JavaScript web assembly right if I can shortcut straight to that optimizer why wouldn't I do that and the reason why that's not going to be true is because JavaScript is just too much of a dynamic language it's extremely dynamic you can do things that no compiler ahead of time could could optimize at for you can do really unsafe things so compiling to JavaScript web assembly would almost in every cases be significantly slower and if you think about it it makes sense right because like your browser right now it's going to compile like like v8 for example does it's a combination of it starts to and use an interpreter on your JavaScript and while the interpreter is running is concurrently going to start or just-in-time compiling some of your code to native code and then that that approach is something that a head of time halation just can't beat when it comes to javascript because of how dynamic it is so the version one of them of webassembly the MVP is they call it is best suited for things like C C++ rust languages that are traditionally ahead of time compiled to native assembly using things like LLVM but but other languages are definitely a stated target and being worked on like support for these native these other languages is coming very soon things like Java Oh camel Reason alum all of these things are coming very soon and to give you a kind of a little bit of taste of that there's there's a language called turbo script that was created specifically for web assembly it'll only targets web assembly and this is what it looks like hopefully everyone in this room can can read this fairly well especially if you've used typescript because it basically aims to use the exact same syntax of typescript it has some semantic differences at least currently because like for example you'll see you're seeing float 32s and there'd be a 32s and stuff like that which is something you don't have to worry about in JavaScript but but the idea is to be very familiar syntactically so that you could very easily either port your existing something some existing code to this or you know write your your utility libraries and stuff like that in it but there's you know some some caveats in which you see at the bottom when you when you allocate some memory we're creating this coordinates you have to explicitly call to lead on it which is like you know the same thing as like malloc and D malloc if you're if you're familiar with the sea side of things so when should i target webassembly this is one of the more common questions that get and right now the the real use case for it is things that are gonna be heavily bat cpu-bound so number of computations utility libraries things that don't actually interact with things like the Dom or don't require garbage collection which in a lot of non-trivial apps is can sometimes be quite a few things the the the quintessential example is gonna be games which most of the people in this room probably don't do games and my I don't do games actually anecdotally I I started doing programming in games that's what got me into it it's probably many of you in this room as well and then I'm quickly realized that may in games doesn't mean playing games listen so it said making a game was it was not fun for me but but your old low you'll likely be consuming webassembly either without even knowing it or you know knowing it as well like you'll be consuming these binaries and I'll give a couple examples like this is the web assembly is very early but there's already production use cases for it one of those use cases is source map support web Mozilla moved they have a source map generation library that's used by a lot of different projects whether you know it or not you probably are using it under the hood and they ported that over from JavaScript to rust and that rust gets compiled to web assembly and they saw at over five times improvement in speed five point eight nine which is huge which is a very non-trivial improvement and it's so early that this is going to just naturally increase as browsers start to actually optimize web assembly itself that will just naturally get faster there's been a lot of also-- experimentation in the JavaScript world there's a port of the the force Direction algorithm from d3 over to web assembly as well so that you can get that performance benefit because it's like d3 a lot of this stuff that it does is actually just algorithm stuff it has nothing to do with the Dom whatsoever and that's stuff that you can move off into web assembly and get a huge burst boost in performance but these other use cases are imminent and excuse me I'll talk about those here here in just a short bit but so that we better understand what it is we're dealing with whatever assembly is what it can do let's let's look back and so let's look at what was that binary stuff that I was showing you earlier I showed that CC function that gets compiled down to that web assembly you know if you're like me and yeah like I look at this and I'm just like ah like I don't know what this means and how you know like how do I use this why do I care how would I do bug this binary can be just a little quote unquote too timid intimidating so the the pro tip I'm going to give you is don't worry about it if you don't have a lot of experience with binary don't get intimidated by that even today even though it's so early there's a lot you can do without needing to even touch actual binary data tooling aims to make this a non-issue right now it's you know again since it's a little early you might get some of the edges and might need to deal with a little bit more but yeah so one of the things you can do is is the is use the textual representation of web assembly if you're needing to deal with the actual binary and what that looks like is that that factorial function we had in which we compiled web assembly in the textual representation would look like this which if you're if you're not used to looking at like assembly languages and stuff like that can be a little intimidating right you know it didn't be like um I don't quite know what the heck this is but but let's break this down a little bit and actually learn the fundamentals of web assembly let's do that right now so to understand web assembly have to understand that it's a stack machine language which differs from a traditional assembly languages which is typically called a register machine language and so the question you might be asking is well what the heck is a stack machine like well to understand what a stack machine is we first need to really truly understand what a stack is and a stack is a data structure in which you have two operations you can push things on to the stack and you can pop things on to the stack and whether you've heard that terminology or not I can almost guarantee everyone in this room has used a stack even if you didn't know you were using a snack because it's such a common data structure but let's look at what I mean by that so we've got a little little visualization that I created we've got the stack and we've got an item well there's two operations we can do we can push and pop so let's go ahead and push that item on to the stack now when we've got another item basically we have 200 operations we can do we can either pop the existing item off the stack or we can push this one onto the stack when you push things always go on top when we've got another item guess where it's gonna go it's gonna go right on top so we've created a stack which as you can imagine like like a stack of dishes or what have you the analogy holds very true the other operation was the pop so if we want to pop something it's always going to take from the top of the stack you can't pop I wouldn't be able to pop the bottom that's like all the way at the bottom while keeping everything else in place it's always first in last out for so let's go ahead and pop these things off very nice so last in first out of our suit earlier I said said opposite in the last slide so you basically the last thing in is the first thing to get popped out which is I think in Tim intuitive so if we take this data structure and we apply it to the stack machine example that means that basically a stack machine is instructions on that stack we're taking instructions putting them on the stack and the machine is then going to pop those instructions off to evaluate them so let's take a look at a very simple example of this 1 plus 2 and pretty much every programming language this is how you do addition in web assembly they they the textual resent representation is going to use something called mnemonics which is just a fancy word for a textual word to represent that binary instruction so that you don't have to remember those binaries and this is the buna monic for adding this is a 32-bit integer and we're going to use it for doing addition and this is how you'd actually add that 1 plus 2 you can see here that we've got the the number one which is a 32-bit integer constant and a number 2 and then we're going to add them together let's look at how this actually would be evaluated by a stack machine we've got the the number one it gets pushed onto that stack we've got the number two it gets pushed onto the stack and then we push the add instruction onto the stack which is going to pop off those first two instructions add them together and then place them back onto the stack the results so the result of those those the 1 plus 2 is going to get put back on the stack automatically for you that's what the add instruction does adds them together places it back on the stack if we wanted to do something then with that resulting value that number 3 we could use something like call we could actually call the log function so the log function is going to get called with that number 3 the result of the previous instructions hopefully everyone's following so far but when you're debugging your actual compiled not handwritten webassembly you're gonna notice that compilers are gonna apply optimizations and so it can sometimes get a little hard to fully understand like what is going on here and so I like the simplest example the one we were dealing with every compiler in the world is going to basically know I can just turn that to three like that's a very simple thing it knows that at compile time but but I hope that gives you the idea of like some of the optimizations a compiler is going to do that can make it a little harder to grok if the stack machine stuff is a little intimidating because they can get really like hairier once you're enough fairly if you have a function body with a lot of instructions they can get kind of confusing because like a one instruction you're looking for could be way up higher on the stack most tooling is going to use something called an abstract syntax tree syntax which is a different way of visualizing the exact same data and this makes it much easier for a human being not a machine because machines love stacks much easier for a human being to actually understand what this so with this example this one plus two add them together and call log in the abstract syntax tree form it would look like this so here we can see a much more natural representation we can see that the the argument to call is the ad and the argue the two arguments to add is those two one plus two so this becomes more natural and instead of being just one long series of statements it becomes you know just arts to drift more right with the nesting and actually these are called s expressions is it anyone in the audience a lisp user or who have ever used Lisp excellent wonderful wonderful wonderful wonderful so that's that's basically what these look like they look very similar to lists because Louis invented s inspections 60 years ago so if you're familiar with Lisp awesome you know I think you'll it'll feel right at home so this is all great hopefully you now have a general basic understanding of what webassembly is what exactly is missing right now though because it is early I've said that several times let's take a look at some of that stuff and that's one of the more important things and a lot of reason why webassembly has not just skyrocketed in usage is that it's missing direct access to the web api's and you if you if you dive into the community you might hear them talking about web IDL which is the specification representation of like the Dom specification representation of the api's that are provided to the browser the reason why some people might say Dom api's but that's technically not correct is because there's ap eyes that are actually don't interact with the Dom like set timeouts at interval those are actually part of the quote unquote Dom specification but are not actually part of the dog so web IDL is what you might hear people refer to the mass but in web assembly you can't access those directly you can't call set timeout or set interval directly within web assembly instead you have to call through javascript there's a really fairly great foreign function interface which is the how you call through web assembly into JavaScript and you would call some JavaScript code which would then call this that timeout set interval or manipulate the Dom append text those type of things those things you can't do in web assembly directly which is a big deal for for a lot of projects that don't deal with like algorithmic stuff but it's a very stated goal of web assembly to support these things and there's proposals in the community group and working group that are working on adding these support right now like it's been actually in progress for many months and very soon we will get that access and it'll open up a huge number of opportunities for both the libraries and frameworks to do things for you transparently automatically but for you as well a related thing that's missing is garbage collection and it kind of comes hand at hand right if you created a Dom node within web assembly well no JavaScript objects are do traditionally garbage collected so if you created that in web assembly and you don't have access to the actual browser's garbage collection how does it get collected right and what happens if you pass a Dom element from JavaScript to web assembly or vice versa and needs to keep track of those those garbage routes and be able to collect them appropriately it's necessary to deal with the JavaScript and the web IDL stuff this again is also being exposed to web assembly it's gonna have a basically a very similar syntax to to how the Java byte code or the CLR bytecode works you have a concept of structs and you'll be able to define the different fields when I say you I don't necessarily mean everyone in this room hopefully tooling will make that obsolete and you know automatically do that for you behind the scenes the other thing that that I'm personally very excited about is multi-threading and when I say multi-threading I mean true multi-threading being able to create the equivalent of an actual pthread none of this message passing and serialization across things and why this is why this hasn't been supported in JavaScript is fairly easy to understand javascript has a very low barrier to entry you don't need to know compilers you don't need to know anything you basically just create a text file with script tags and inside that script tags you can start writing JavaScript which is phenomenal it's one of the biggest reasons JavaScript is so gross so great but because it's so easy it's also so easy to shoot yourself in the foot and if you give your given where if you were given multi-threading people would potentially significantly abuse this on traditional websites they do multi-threading things because they heard multi-threading is great on things that don't shouldn't be multi-threading and they'd create deadlocks and lock up your main browser thread and stuff like that so this is a very tough sub subject to add to the web browser because you've got to be careful but it is a stated goal that they want to support native actual multi-threading and the idea behind that it like the number one reason why is to be able to enable things like languages like Erlang which have very unique concurrency needs which is going to require things a go and all these things like being able to create those abstractions on top of those threads it's going to be a huge benefit to advancing the web and being able to support all these different languages and there's there's actually many more specifications that are currently in progress and they're advancing very quickly but I just don't have time to talk about all of them but the goal is to basically make nearly any language be able to compile to web assembly since we're at a rack Club let's talk about how is this going to actually impact react in the long term what webOS and what react could do is it actually could create a we're a reconciler that gets him piled to web assembly it could use like chances are just because I know some of the the react team chances are they'll probably write it in okay reason but they could use it in C++ or what have you and the reconciler I don't know who's gonna be a talk later about the reconciler here at the cuff but the reconciler is basically just the thing that does the actual dipping of your virtual Dom nodes when you render a component and then there was a previous rendering of that it needs to diff and see what has actually changed and with the new fibre architecture it's a much more complicated that actually reimplemented can basically in the middle of doing some sort of render either pause or abort or do something else like that this is a prime example of when we get garbage collection for web assembly fibre would be a prime candidate for doing these sorts of things and if you want to learn more about fibre there's like so basically the idea of fibre you can pause then and come back to work later you can assign priorities with different things so if you've got like an input box that I don't know if they'll be talked about this later but if you've got like an input box and you're typing into them input box how many of us have had to deal with the fact that like everything's slow now like you when you're typing into the input box each character gets added is super delayed like I've dealt with that so much and in reality all you really care about is making sure that input boxes is responsive anything else on the page is usually second and that's what fibre can enable us to do it can prioritize that input box while Bay's basically being like I don't care too much about everything else so it can be rendered at a slower rate and it can also then reuse completed work that it's done so if it's done previous renders they can Gendry use it if you want to learn more about that there's a really great talk by Lynne Clark called a cartoon intro to fiber and I'm gonna give you guys a second because I really think that if there isn't a fiber talk here I really recommend taking a look at this talk because it will really make it click for you about what fiber really is alright so moving on is an example of like something that react could do something very similar amber has already is already basically ahead of the game in some respects they have their glimmer virtual machine and they're actually in the last six months have been in the process of writing that in rust compiling that to webassembly now it's a little different not a little essentially there's some significant differences between how glimmer works and how react works but some of the principles are the same that you know they basically need to do some sort of dipping and figure out what changes they need to make the actual dub but ember is already basically trying to prove out whether with today's API is without even the garbage collection support can they make this something that's actually faster than doing it in JavaScript so it's I think it's a little early to know whether this is actually going to pay off for them but it's a very exciting for me to watch and learn from what what works what doesn't work things like that another thing that I think that a lot of people will end up doing is actually writing the react components in another language and compiling those two web assembly languages like reason which there's a - I know there is a talker later today that's going to introduce reason reason right now gets compiled to JavaScript but they definitely they're already actually working behind the scenes to do some experimenting with compiling reason to web assembly directly it's going to be primetime it's going to require that garbage collection support but this is something that I think is will be a real thing and like I'll give a very quick example of what reason looks like I mean looks has a very similar syntax to JavaScript with a kind of a flavor of Oh camel but this could potentially you know basically wow your application runs and works react actually doesn't care about all it cares about is give me some virtual Dom and then I will somehow diff that and apply it to the actual the actual physical Dom and so using another languages like reason or dart or what have you or even a brand-new language that has not yet come out I think we're gonna get an actual revolution of brand-new languages here soon would be a very natural thing for for web assembly and it's possible to do these things right now but the missing direct access to the Dom the missing garbage collection those type of things it does make it a little bit less of a of a compelling story because there is a cost to calling from web assembly to JavaScript if you have to keep doing that and so like projects like glimmer what they're doing is they're batching up they're creating like a change list and then sending that change list as binary over to JavaScript JavaScript will then read that change list apply it which is a clever inefficient way of handling things but so I think in the not-too-distant future instead of afraid to react as react Jas I think we really should just continue to just refer to it as just a plain old reacts because I think react will end up being written in a totally different language other than JavaScript and a lot of people will end up be using it in a totally different version than JavaScript totally different language so there is a in the not-too-distant future we could be not using any JavaScript whatsoever and still writing react I think is wonderful so how how do I get started right now it is literally but if you do if this excites you like it excites me how do I get started right now well the first thing you should do is just go to web assembly dot org because you'll learn about it has great resources on the different toolings the different projects that are happening the specifications and you're also welcome to get involved with the specification process if this is compelling to you or your company their community group is completely open to the public you don't have to pay anything to get involved you can and if you want to you could even just sit there and listen there most of the community group meetings are online through Google Hangouts if you want to really get down to the nitty gritty of web assembly and that's where you want to start there's projects like the web assembly Explorer which is kind of like a jsbin type of thing where you can type C or C++ on the left see what the actual web assembly output is and you can actually even see the x86 output from Firefox and there's a little tap there's a little toggle to also see the LLVM ir if you don't know what that is don't worry about it it's probably not something that's interesting to you unless you're a compiler person right now the de-facto way of dealing with web assembly for like the average like C++ use case is gonna be some pressure called M scripting which actually is many many years old because it was originally created for the Azzam Jas project by Mozilla and it's very similar to how you would use GCC the API is almost identical you pass in the files that you want to compile and you'd get a resulting webpage and right now because web assembly cannot you cannot load a web assembly application without some sort of HTML or and JavaScript it does create you a an HTML page that's an optional thing but in the future you'll be able to load up a web assembly page without any corresponding Java Script know HTML those type of things but currently we're not quite there yet if you want to go a little more high level and not do it and try and not deal with webassembly too much there webpack is actually adding first-class support this is a major major thing for the JavaScript community they actually got a 125 thousand dollar grant from the Mozilla Foundation Mozilla open-source foundation remember the actual what oh s s means but this grant is explicitly to add that webassembly support the web pack and so what what I mean by that is you'll be able to do things like this you'll be able to import web assembly directly and it just works it figures out all of how how things get added and linked together and dealing with the complexities are on sharing memory linear memory between different web assembly modules and right now this is how you you can actually use this today if you're very venturous you can actually this syntax works today in in web pack but they want to also this is asynchronous they want to also support the synchronous use case as well so that you don't have to you know learn load some sort of external library just-in-time or something like that and as that support gets added more and more to to web pack you're gonna have things like our rust loader or a reason loader or a dart loader or some new language loader so that basically you can write your your your rust or your reason right next to your JavaScript and everything just works you don't have to configure some crazy compiler tool chain or install things like that it just loads automatically and links correctly to your JavaScript which is I think once this stuff gets a little more stable I think that's really what's going to help make whoever suddenly take off browser support is actually it's supported in every major browser today so as of last year it was it the support was added to the last holdouts were edge and Safari but now it's supported in every major browser and there are actually polyfills to be able to basically support there's a couple different methods to supporting like you're doing backwards compatibility like if you need to support IE i 11 or what-have-you one of the ways you can do that is at the compile time you can generate a azzam j/s version which is basically a JavaScript version that the browser knows more about and can optimize around an alternative way of dealing with backwards compatibility is there's the community group ships a actual interpreter which might sound like it doesn't perform well but in practice actually performs really surprisingly well so that you'd ship the actual binary and then the binary interpreter and it gets it would work in any browser all the way back to you know ie6 so to kind of wrap things up I'm gonna I'm gonna talk a little bit about this revolution and why it's a little bit I think it's just beginning besides the garbage collection the multi-threading and stuff like that I think that web assembly because it's so unprecedented it's actually going to unlock a lot of opportunities that we're never possible before so like let's go back to that that definition I gave you efficient low-level byte code for the web I think we should strike this out the last part out I think we should just call it an efficient low-level byte code because they're already people using and planning to use web assembly for cases that were not originally thought of the if you've heard of aetherium with the whole block you know the whole blockchain type of thing aetherium their virtual machine is actually being moved to use web assembly so they'll run your your theorem contracts in their vert in their web assembly virtual machine they have actually got a slight customization to the virtual machine for there because they have like a budgeting constraint that they have to do like your script you can only run for a certain amount of time but aside from that there there's a lot of talk not a commitment yet but there's a lot of talk about maybe the operating systems supporting web assembly natively think about Android and iOS they had to basically invent their own sandboxing mechanism because when you run a traditional native app and a native app can do very malicious things by default but on devices like iOS and Android they knew from the very beginning they wanted to prevent a lot of those things from happening and so they created their own sandboxing mechanism but those sandboxing mechanisms are proprietary and not portable between different operating systems not portable to the web and projects like Chrome OS have basically proven that Google and Apple and all these companies are very interested and figuring out how they can combine the web and the actual operating system itself so I i'm gonna hedge a bet if anyone here actually wants to bet me I will bet several hundred dollars I'm not joking about that that eventually webassembly will become the de facto binary format for applications in general that you'll instore on iOS or Android you'll download your app and it will actually run in webassembly now I'm not speaking for them so I don't want to don't any what I'm angry with me for promising that to you but I I just feel so passionately about webassembly and I see the writing on the wall how this is going to be really great so if this is interesting to you I I'll be available afterwards and you guys are more than welcome to talk to me talk me up and ask me more complicated questions or specific use cases for your company and stuff like that so I really appreciate your time if you'd like to follow me on Twitter it's an underscore J Phelps make sure you get the underscore because there's a teenager who tweets football and basketball stuff and a lot of people like you know they add him and follow him and so thank you very much and [Music] thanks Jay [Music] [Music]

Channel: Real World React

Views: 3,367

Rating: 4.9545455 out of 5

Keywords: react, reactjs, redux, webassembly, wasm, reactathon

Id: s2ccNDxRqpo

Length: 36min 32sec (2192 seconds)

Published: Fri Mar 30 2018