Gant is back on the show! He joins Robin and Mazen to talk about what’s new in React 18, and how it ties back into React Native.
Gant is back on the show! He joins Robin and Mazen to talk about what’s new in React 18, and how it ties back into React Native.
This episode brought to you by Infinite Red! Infinite Red is a premier React Native design and development agency located in the USA. With five years of React Native experience and deep roots in the React Native community (hosts of Chain React and the React Native Newsletter), Infinite Red is the best choice for your next React Native app.
Helpful Links:
Connect With Us!
Todd Werth:
Welcome back to React Native Radio Podcast. Brought to you by Twitter. Turns out if you have $44 billion, you can edit a tweet. Episode 233, react 18 and the future of React Native.
Robin Heinze:
Hey, Mazen, how much sleep did you get last night?
Mazen Chami:
Probably a total of four hours.
Robin Heinze:
Did you have someone interrupting your sleep, or what's the story there?
Mazen Chami:
Yes. So my wife and I have a, today, five-week-old. Safe to say his sleep is a roller coaster. As much as I hate roller coaster, and I love my sleep, it's been a rough couple five weeks, but we are getting there. We're figuring him out, and I think he's figuring us out.
Robin Heinze:
I promise they do start to sleep eventually.
Mazen Chami:
Yeah. When is that?
Robin Heinze:
Well, Ellie's three, so I'm still waiting.
Mazen Chami:
Yeah, thanks.
Robin Heinze:
Well, congratulations, and welcome back.
Mazen Chami:
Thank you.
Robin Heinze:
Obviously if you've been listening to the podcast religiously, Mazen's been gone for a few episodes. He was on paternity leave, and we are so happy that he is back. You'll also probably notice that I am not Jamon.
Gant Laborde:
What?
Robin Heinze:
What?
Gant Laborde:
Oh.
Robin Heinze:
I've been working on my Jamon impression, but it's not there yet. He's in Florida having way more fun than the rest of us. He's already been to Disney World a couple times. He's sending us pictures to make us jealous, but yeah, he is gone for a couple weeks, but we can do it without him. Plus, I get to call myself the CTO when he's gone. That's the deal.
Mazen Chami:
There you go. All worth it.
Robin Heinze:
Also, we do have a special guest cohost with us today, our fabulous owner and CIO, chief innovation officer Infinite Red, Gant Laborde.
Gant Laborde:
What what? Woo!
Robin Heinze:
What?
Gant Laborde:
Yeah!
Robin Heinze:
How you doing?
Mazen Chami:
Calm down, everybody.
Gant Laborde:
I'm just happy to be here as a discount Jamon. I'm Great Value Jamon, is what happens.
Robin Heinze:
Wish.com Jamon.
Gant Laborde:
That's right. Hold on. Sisu, Tractor, React Native.
Mazen Chami:
There you go.
Gant Laborde:
There you go.
Robin Heinze:
Of course, I'm Robin Heinze, obviously, your host for the day and friendly software engineer at Infinite Red. I live in Portland, Oregon with my husband and two kids. I'm joined, as I just mentioned, I'm joined by my fantabulous-
Gant Laborde:
Ooh.
Mazen Chami:
Fancy word.
Gant Laborde:
Yeah.
Robin Heinze:
... co-hosts, Mazen and Gant. Mazen lives in Durham, North Carolina with his wife and newborn son, who we've seen some pictures of. He's pretty cute.
Mazen Chami:
Thank you.
Robin Heinze:
Gant, as I said, is an owner of Infinite Red. He's a New Orleans native. He has a long list of titles, which I can't remember and won't list. You can catch him speaking at Devnexus next week and Reactathon in the Park as well. Before we get into our topic for today, I do have to say that this episode is sponsored by Infinite Red. Infinite Red is a premier React Native design and development agency located fully remote in the US and Canada. If you're looking for React Native expertise for your next React Native project, hit us up. You can learn more on our website, infinite.red/reactnative. Don't forget to mention that you heard about us through the React Native Radio Podcast. Also, imagine working with a team like Mazen and Gant. Who wouldn't want to work with them? If you're a senior-level React Native engineer located in the US or Canada, go to careers.infinite.red. We'd love to hear from you.
Gant Laborde:
I just want to say that Infinite Red is so much better than that company Finite Blue. You do not want to work for them. They're just not as good.
Mazen Chami:
Stay clear.
Gant Laborde:
Yeah, React Native company to go work for Infinite Red.
Robin Heinze:
Infinitely better.
Mazen Chami:
I'm guessing they work in Flutter?
Gant Laborde:
Oh, Finite Blue, yeah.
Robin Heinze:
See, if you're a Flutter dev out there listening to this, which I don't know why you would be, but a prime opportunity to start a consultancy doing Flutter. Call yourself Finite Blue. All right. Let's get into our topic, which today is we're talking about React 18 and how that fits into the future of React Native. So if you missed it, React 18 landed just a couple weeks ago. It's a major, major release introducing a lot of new features that have been in the works for a while, specifically around the concept of concurrency. So if you don't know what concurrency is, Mazen, Gant, what's concurrency? Why do we care?
Mazen Chami:
I think the best way to describe concurrency is the way React kind of posted in their blog. Think of it as a way to prepare multiple versions of your UI at the same time. I think that's really important, because that gives you a lot of performance improvements. Some people might be thinking, "Well, multiple UIs, that should bog things down. Why would I want to load two to three different versions of my UI, and then all of a sudden have my performance boost?" Well, as we'll get to later on, React 18 does a really good job of letting you load multiple versions of UI, and that's valuable, because it unlocks a lot of different abilities for you as a developer. We'll also talk about what they call priority queues and multiple buffering later, but just know that you can load multiple versions of your UI at the same time.
Gant Laborde:
Yeah. To me, you've always thought of React as synchronous. We look at it in a linear form. When you're looking at something linearly and you have a very synchronous structure to it, the best thing that's helped me kind of feel more comfortable is that the benefits of asynchronous, you have the options for being able to be optimized. You have the options for when something else is interrupted or has to be interrupted or weighted, you can choose a better path of action.
Gant Laborde:
I guess one way I would say it is you wouldn't want to go down each maze and then just get all the way to the end before you can turn around and then go find another path. So in a certain sense here for me, and it's not probably exactly the same, but just thinking of React 17 as a very synchronous sort of framework, and then think of 18 as more asynchronous.
Robin Heinze:
It's like if you're a developer and you have to run some super long running script, and there's all these memes and comics and stuff about developers running their tests, and it takes 45 minutes, so they're "working" and they don't have to do anything else, and they're just sitting at their desk with their feet up while this script runs. But instead of just doing nothing while that runs, if they could get other things done, that's concurrency. It's not having to sit and wait.
Mazen Chami:
So shouldn't be able to sleep in between. Got it.
Gant Laborde:
So, Mazen, you're quite interruptable, is what you're saying.
Robin Heinze:
Yes. Parents are very familiar with the concept of concurrency.
Mazen Chami:
Oh yes.
Gant Laborde:
Yeah, concurrency, it seems like it's a sign of maturity for any programming language. When you first see a programming language, it's just what can it do? Yeah, I say programming language. I'm completely conflating programming languages with a front-end framework of React, right? Okay. But it's the same story over and over again. So I'm going to play my old man hat. Hold on, where is it? Here you go.
Robin Heinze:
I don't know, you can borrow one from Jamon.
Gant Laborde:
That's right. But it's a sign of maturity to think about things in both concurrency and parallelism. It's also a significant optimization, which I have to say kudos to the React team and also the React Native team. They've had a significantly wonderful working mechanism, and rather than adding more and more bells and whistles, they've sort of gotten down to the engine, the core, and then worked on the efficiency of it. I think that's what we're seeing with how 18 and React Native are coming together.
Robin Heinze:
So you actually just led into what I'm about to say really nicely. But I want to make sure that people listening are thinking, "What? This is a React Native podcast. Why are you talking about React?" So before we sort of dive into the features of this React release, I want to make sure we're keeping in mind how this ties back to React Native and why it's important. Of course, this all feeds back into the new architecture, which is the buzzword of the year. If you're building things in React Native, I'm sure you've heard the term "the new architecture", just this big rewrite that's coming. Much of what's happening in that rewrite is critically dependent on the concurrent features that came with this new React 18 release.
Gant Laborde:
Robin, we need a cooler name than the new architecture. Can you give us anything that would be better than that?
Robin Heinze:
React Native Synergy, React Native Unprecedented.
Gant Laborde:
This summer, React Native Synergy.
Robin Heinze:
I think we just need to go full corporate buzzword. So yeah, as we talk about these React features, just keep in mind that all of these are very closely tied to the features that are coming down the pike with React Native Synergy, the new architecture.
Gant Laborde:
If that takes off, that's your fault.
Robin Heinze:
I would like credit for that.
Gant Laborde:
Yes.
Robin Heinze:
Right. So where should we start? There's so much here. I want to talk about the sort of root, if you will, which is kind of a pun, if you know what I'm going to say. The biggest visible change that React developers will notice and have to actionably change in their apps is that instead of using ReactDOM render, they're going to have to call a new API called create root. This is significant, because in React, the root is sort of the top-level data structure that React tracts to re-render. In the legacy API, it was just sort of attached to a DOM node, but the user couldn't see and didn't have access to. But now you're creating a root by calling this create root API. So you actually have access to the root and all of its concurrent features.
Gant Laborde:
Yeah. I like that. I like that a lot. ReactDOM render sort of imposes this idea that will you please let this React code inside of your already existing website? Maybe that was great in 2013, but I think now, it's the core of what people are building their websites on. So it is the root.
Robin Heinze:
Right. Yeah. We're not sort of attaching ourselves like, "Hey, can we sit here?" No, it's like, "No, we are the tree."
Gant Laborde:
Yes. I like that. We went from, "Can I sit at the cool kids table?" "We are the cool kids table."
Robin Heinze:
Yes. So that's probably going to be the most visible breaking change for React users. I don't know if React Native users will see that so much. Then I think one of the coolest and probably will be the most used feature coming with this release is automatic batching, which is really awesome. So what automatic batching means is if you have multiple state changes, outside of a normal event handler like unclick or unpress, before, if you had multiple state changes in an async function or a timeout function or something like that, each one would cause a re-render. But now with concurrency, those will be batched. So if you have three state changes in a row, it just re-renders once, which is huge.
Mazen Chami:
That's game-changing. That's really good, because sometimes I think I've run into this in the past where let's say we're changing a flag and a count, similar to the documentation they have. Sometimes we're checking the count. Let's say the count starts off as undefined, for example. We're checking if the count actually exists before changing it and whatnot, but now that we're only having one re-render happen, we know that it's going to come back with a value. So you don't really have to do a lot of your checks, because instead of accounting for the first re-render and then the second re-render to make sure UI doesn't crash, you know you're just going to get one re-render. Come back with all your data that you're expecting from that function or timeout. So setting a flag or setting a count, you'll know that it'll be set in one rather than two.
Gant Laborde:
Yeah. It's weird to me, because it's one of those things that was a gotcha for React and React Native. You were wondering, and we all kind of got a little bit better as sort of a re-render detective for a while. Like why is this-
Robin Heinze:
like a spidey sense for, "Okay, this is going to [inaudible 00:14:39] a lot of re-renders."
Gant Laborde:
Yes. Yeah, you would have to go figure out. You're like, "This doesn't make sense. Just do the things I want you to do here." Then you move something above one line, and then it would do that. You would just lie to everybody and say, "Yeah, I fixed it, and I totally understand why." But no, there's all these weird rules, and you kind of see this. I know that here we're fans of using MobX-State-Tree a bit, but Jamon was showing me this one where if you are modifying in MobX-State-Tree, and I'm sorry if you don't use MobX-State-Tree out there. Just follow through with this. This is like a little gotcha that he was showing me, that you're firing an action, but then you have an async. You weight something inside there. Then you do something after that. The way the promise is built out, you wouldn't have that value back in time.
Gant Laborde:
I feel like that's the same problems that we were seeing inside of async with re-renderings, is that if you're setting state after async, if you're kind of dealing with these, all of a sudden, you're like, "What's going on?" You had to know some magic secret that was like, "Okay, well, you have to know these. Come here." I feel like people tripped over this constantly. The fact that the framework itself is going to fix that for you and batch these processes, this is... Whew, all right? I don't know if I can keep up with those.
Robin Heinze:
It feels like a really nice natural progression after they introduced hooks, because now with use state, you're managing all your state in these little bits and pieces, instead of one huge state object. Naturally, you're updating state multiple times. So that kind of introduced this problem, and now this is sort of the resolution. Okay, so now you could update your little pieces of state all in a row, and we'll make sure that you're only re-rendering once.
Gant Laborde:
Right, and let's just face it, React is a glorified diffing and re-rendering engine, right? Deep down at the core.
Robin Heinze:
It's basically Git. Can we replace Git with React?
Gant Laborde:
Oh my goodness. You just inspired somebody to-
Robin Heinze:
Million-dollar idea.
Gant Laborde:
That's their TED Talk.
Robin Heinze:
Another feature of this release is called transitions. Mazen, can you tell me a little bit about those?
Mazen Chami:
Yeah, react kind of distinguishes these between urgent updates and transition updates. Urgent updates, kind of think about it like when you're typing into an input or you're clicking a button, you don't want a delay. So if I'm typing in an input, like hello, I don't want to press the H and then have a delay, and then the H kind of shows up a couple seconds later. So these are kind of like urgent, get it done right away so that user doesn't really see any glitches, essentially, on the screen.
Mazen Chami:
Transition updates, basically when you're transitioning from one UI to the other, they will be interrupted by urgent updates. So whether if you're making a change within a transition, the urgent update would happen, and then the transition would kind of go. Now one big thing with the transition update is it does come with a... I wouldn't call it a hook. It's called a start transition function. Then within that, there's a callback. That's when your transition happens. So that's how you kind of start your transition, delay, search for a query, or set an input, set a value along the way.
Robin Heinze:
So I think a good example of this concept would be if you have a whole list of things, and you have the ability to search or filter those things, and you can filter by clicking buttons or you can filter down by entering in a keyword that filters the list. Interacting with those filter buttons or entering text in to a search bar, those are the urgent updates that you want immediate feedback. But then refreshing the list and showing the new, the reduced list, that's the transition update. That's the sort of the update that can take a little bit longer.
Mazen Chami:
Totally. I think that's a very good example, Robin. I think the one, when I was kind of reading into it, the thing that came to my mind was it kind of sounded like the transition parts were almost debouncing. So debounce, we kind of wait for the certain intervals along the way, and then kind of return the value of the function, create a search. This kind of seemed like that, right? What's urgent is the typing in our filter. What's not urgent can wait for us to kind of finish typing is then showing up our filter. So then it's kind of like the debounce. When we're done typing, boom, show me my next transition statement.
Robin Heinze:
Yeah, that does seem similar to debouncing.
Gant Laborde:
Yeah. The concept of urgent updates for when you're typing, and we're talking about... There might still be people who don't manage the state of a text component. So we're talking about managed components where we are telling them we control all of the state of the item. This is an interesting moment, because there are still people who just let things manage their own state, in a certain degree. But once you start to really get in there, and you're telling something what the value is, I've found that just as simple as having a text box and managing the state of that, you do see a little flicker sometime. You see a little problem sometime.
Gant Laborde:
Originally, it was just kind of okay. People were like, "Okay. Hey, at least I'm able to get this to work." I'm glad, because those kinds of problems aren't acceptable anymore. I think that with the new architecture, well, specifically with React 18 and urgent updates and those kinds of things coming through, we actually have the tools to manage those flickers, those weird moments where it shows something you didn't want it to see. You can actually dig down and identify and work with those. I think that's really, really important, because it just shows we're hitting a new bar. We're hitting a new gear with the expectations of what React Engineers should be able to do.
Robin Heinze:
Totally. This is definitely feels like a new era for this framework. Just to tie it back to React Native, again, I'm guessing this will have a huge impact with Fabric and with JSI, which if you don't remember, JSI stands for JavaScript Interface. It's essentially what's going to replace the bridge. It's the new way of communicating between React Native and Native that doesn't rely on these JSON blobs going slowly back and forth over the bridge. So much, much quicker.
Gant Laborde:
And you mentioned Fabric for Fabric rendering integrates with React Suspense and all these concurrent features as well inside of React Native.
Robin Heinze:
Yeah, and these will all, I'm sure, take advantage of these transition concepts, sort of concurrent UI batching. Let's move on to Suspense features. Suspense is another word that you hear a lot.
Gant Laborde:
I know. Should we tell everybody what Suspense is at this point, or should we just-
Robin Heinze:
Should we keep them-
Gant Laborde:
In suspense?
Robin Heinze:
... in suspense? So what's Suspense? What is it?
Mazen Chami:
So I've used Suspense in the past, and it was very limited in its scope. You kind of had to use react.lazy to create your Suspense components, and then it kind of worked, in that sense. Now, it sounds like in React 18, it's being moved into its own component. Think of it as a UI loading state. While you wait for your data to return from an API, you can kind of have a loading spinner, whatever your design team kind of wants in that. So moving away from the limited version, now it's expanded to being used concurrently. Obviously we talked about the transition. When combining it with a transition API, I think we have a good, seamless, un-suspenseful transition maybe, while leaving everyone in suspense.
Gant Laborde:
We may or may not. Who will know? We throw away our re-rendering hats to grab Suspense hats, so it's worked out perfect. But the simplest one for me is that people used to wait for some kind of asynchronous thing to load. Then you would do this disgusting code that you'd have to explain to new people at JavaScript where you would say, "That thing that loaded and the component that needs to actually consume it."
Robin Heinze:
Which is so normal.
Gant Laborde:
It's so normal now.
Robin Heinze:
It became so normal, but it's not normal.
Gant Laborde:
Yeah, yeah. It's one of those things that's like a language shock. Just the concepts-
Robin Heinze:
I'm like, "What are you doing?"
Gant Laborde:
Yeah. Well, this has this thing that it needs, so it has to exist, and then I'll go ahead and deal with it. You see this constantly in code. Then, of course, what you could do is go write a component that says, "Okay, give me what you want as a child element, and then give me what you want me to show them as a property. Then what I will do is I will switch them out for you." We could all write that tomorrow, but unless that was actually tied into the framework, that was actually tied into the benefits of what's coming through with React 18, it would just be that simple. We might as well just keep the and and. So to me, it's going to make it a lot cleaner to read code, componentize that logic, actually tie into the framework a little bit more. Hopefully, if anything, it actually keeps the code in a little bit less suspenseful, because you know what it's actually doing.
Robin Heinze:
I think I'm going to miss the and and.
Gant Laborde:
Oh yeah. Oh, you always miss the... Here's the curse of being witty, right? You're often the only person who enjoyed it.
Robin Heinze:
Are you saying I'm witty, Gant? Or are you saying I'm not witty?
Gant Laborde:
You're extremely. I'm saying you're probably too smart [inaudible 00:25:43] for witty, and I would not want to be the person who has to code with you. I don't want to be left behind.
Robin Heinze:
Awesome. So Suspense I think was sort of already in React 17 optionally. But now with React 18, you can also use it on the server. So if you're doing server rendering, you can now use Suspense, which is really cool. I think it also works with code splitting now. So the idea is your server can render placeholder HTML while continuing to load the rest of your actual HTML. So the really slow parts of your UI won't block the rest of your UI from loading.
Gant Laborde:
Yeah. It's obviously very exciting for the React folks more so than I would say the React Native folks on this one.
Robin Heinze:
Yes, definitely.
Gant Laborde:
Because, yeah, you see React is really working well with the back-end, sort of front-end coming together a little bit more, and then for React Native, we're more excited about-
Robin Heinze:
Yeah, we don't so much get the back-end, front-end. What is a server?
Gant Laborde:
Is that where I store... Is that for my Fire store or my AWS DynamoDB? Is that what's going on?
Robin Heinze:
There's a reason they call those serverless.
Gant Laborde:
Right. Yeah.
Robin Heinze:
We don't like servers here.
Gant Laborde:
If we could just store everything without it, it'd be fantastic, but it definitely feels like we, as React Native developers, will be more inclined with Fabric, with the interoperability features that we've already kind of talked about. This one is kind of like a neat.
Robin Heinze:
Neat-o.
Gant Laborde:
It's a neat thing. Oh, that's cool.
Robin Heinze:
We're happy for you. What else? Is there anything else worth mentioning? Looks like there's some new hooks.
Mazen Chami:
Mm-hmm. There's one that I kind of really like. It's useId. It just generates a unique ID on the client and the server. So if you've ever used-
Robin Heinze:
There you go using that word server again.
Gant Laborde:
Right. Fancy.
Mazen Chami:
I think in the past, I used to use the package UUID to kind of get a random ID. So you don't have to have that package anymore, and you can kind of use this useId hook. You just kind of use const ID equals useId function. Yeah, I think easiest place that I've seen it used very frequently is accessibility APIs where you need your unique IDs for those.
Robin Heinze:
Oh nice.
Mazen Chami:
Or if you're generating a unique ID for your user or whatever, your back-end, essentially.
Robin Heinze:
I wonder if it could also be used for unique keys in a flat list.
Gant Laborde:
Yeah, cool.
Mazen Chami:
I could see that.
Gant Laborde:
Well, how are those unique? Are those GUIDs or something? Do you know? Because I don't trust GUIDs. They're just mathematically inclined not to have a collision, but you know some day that's going to happen to you, right?
Robin Heinze:
So one in a billion chance that there'll be a collision.
Gant Laborde:
That means there's seven people every year.
Robin Heinze:
So you're saying there's a chance.
Gant Laborde:
Yes. So you're saying there's a chance. Right, yeah. I don't like my UUIDs being IOUs, so [inaudible 00:29:17]
Mazen Chami:
I'm not 100% sure, because looking at the documentation, it doesn't say what is generated. It just says, "Generates a unique ID." I do see a note that says, "Generates a string that includes a colon token.
Gant Laborde:
Oh.
Robin Heinze:
What?
Mazen Chami:
This helps ensure that the token is unique and it's not supported in CSS selectors or APIs like query select all.
Gant Laborde:
The colon token is where you're reading the token, and then you pause. Then you're just going...
Mazen Chami:
I wish they had an example of that. That's a good point again.
Robin Heinze:
Dynamic IDs are-
Gant Laborde:
It's a fake... Yeah, it's a fake fear.
Robin Heinze:
... Base32 strings. Yeah, Base32 strings use binary representation that corresponds to the position of a known in a tree. There's an a tree. There's an algorithm.
Gant Laborde:
Yeah. I will specifically say that fear of GUIDs has only kept me up at least three nights. It's not real. My therapist says that GUIDs won't get me, so it's okay.
Robin Heinze:
It doesn't look like it's a GUID. It looks like it's a specific-
Gant Laborde:
There will only ever be one.
Robin Heinze:
Its got its own algorithm.
Gant Laborde:
Lie to me Robin. It's got a colon to protect it to make sure. It's got all kinds of things. It'll never get a collision, right?
Robin Heinze:
Never ever. They will pay you a million dollars if you get a collision.
Gant Laborde:
Oh. Hold on. I have some code to write.
Robin Heinze:
Awesome. Well, I think that pretty much covers most of the new cool features for React 18. React Native unfortunately will not use React 18 until the new architecture releases, which we haven't been given a date for yet.
Gant Laborde:
Well, the new React Native architecture can be enabled. So here's a fun fact. It can be enabled in React 68.
Robin Heinze:
Okay. Which comes out soon, right?
Gant Laborde:
By the time this podcast is there, you'll-
Robin Heinze:
Right, by the time this podcast is out.
Gant Laborde:
But yeah, you can actually go back and enable the new... So React Native Synergy can be enabled in 68, but there's a lot more... It's sitting there in plain view in the open source, and we will be seeing continued documentation coming in about how to go ahead and transfer over that. So by the time this comes out, you can go check that out.
Robin Heinze:
We will be working to enable the new architecture in Ignite soon.
Gant Laborde:
Oh yeah.
Robin Heinze:
So watch out for that.
Gant Laborde:
Very nice.
Robin Heinze:
So I think that about wraps it up for React 18. If you're looking forward to Turbo modules and JSI and Fabric in React Native-
Gant Laborde:
C++.
Robin Heinze:
C++, when in doubt, just say C++.
Gant Laborde:
That's it. I've been doing that. that's actually my whole career. C++ is that old. I say improved performance and C++, and people keep hiring me, so it'll work here too.
Robin Heinze:
Keep your eye out for all of these features and more in React Native Synergy, the future of React Native. If you'd like to nerd out more about React Native, check out Jamon's Twitch stream at rn.live or YouTube.inifinte.red. He should be back by the time this episode comes out. You can also join our Slack community at community.infinite.red. We have almost 2,000 React Native developers in there now. I'm sure a lot of them know a lot about the new architecture, more than we do, and would love to talk about it. Where can people find the two of you on Twitter, Gant? Where can they find you?
Gant Laborde:
Oh yes. Well, you can find me @gantlaborde on Twitter, and you could also get a list of places that I'll be speaking at on my website, gantlaborde.com. My website's down right now. I'm doing some updates, so-
Robin Heinze:
Awkward.
Gant Laborde:
If you listen to this podcast and it's up, go get it. If not, those fixes took longer than expected.
Robin Heinze:
Are you telling me you didn't upload a little under construction error page?
Mazen Chami:
His SSL certificate expired.
Gant Laborde:
Yeah, I got in an SSL infinite loop. So what's really funny is if you try to force SSL on your website, and then you try to force it a second way, just because you're like, "Oh, well maybe I'll just do it two ways," don't. Don't do that, because then you end up in some weird infinite loop world where you can't... Just don't do it.
Robin Heinze:
TLDR, Gant messed up his website.
Gant Laborde:
Dude, SSL certificates are not as easy as they should be. I know they're getting easier. I still find ways to screw them up, okay?
Robin Heinze:
You should just use godaddy.com.
Gant Laborde:
Oh. Hey, how much are they paying you, Robin?
Robin Heinze:
They'd have to pay me a lot. Mazen, where can they find you on the interwebs?
Mazen Chami:
So I'm @mazenchami on Twitter.
Robin Heinze:
Perfect. You can find me @robin_heinze with an E at the end, and you can find React Native Radio @reactnativerdio on Twitter. As always, thanks to our producer and editor, Todd Werth, our assistant editor and episode release coordinator, Jed Bartausky, our designer, Justin Huskey, and our guest coordinator, Derek Greenberg. Thanks to our sponsor, Infinite Red. Check us out at infinite.red/reactnative. A special thanks to all of you listening today. Make sure to subscribe wherever you get your podcasts. We'll see you next time.