Name: Deploying, Testing - Lecture 12 - CS50's Mobile App Development with React Native
Uploaded: 2020-03-30T06:15:49.000Z
Duration: 1 h 40 min 18 s
Description: Thousands of YouTube videos with English-Chinese subtitles! Now you can learn to understand native speakers, expand your vocabulary, and improve your pronunciation...

JORDAN HAYASHI: Hello, and welcome for lecture 12, deploying and testing.

Adverbs of degree

So last week, we talked about performance.

We talked about the trade-offs that you get

when you do some performance optimization, that

We talked about a couple of different ways to test against performance, one

So it's built into your phone, and it allows

you to see how many frames per second you run.

We talked about the Chrome Performance Profiler,

which actually runs your JavaScript code within Chrome

and shows you a flame chart of all of the components that are rendering.

We talked about a few different common inefficiencies that we see in React.

One would be re-rendering too often, another

being unnecessarily changing props, which may actually

And then we ended the lecture with a demo

of this animated API, which allows us to run

some calculations on the native side of things rather than within JavaScript.

So this week, we'll give a high-level talk about deploying apps.

So the way that you deploy in Expo is by building the app locally, and then

Before you do that, you have to make sure to set the correct metadata

And you can find out exactly what those are at this Expo documentation link

Then you go ahead and build the app using

It's basically just an alternative to the XDE

because the XDE does not allow you to build the app within that GUI.

The way to do this is to install the script.

So you do npm install global exp, just like how

You then build it by doing either build colon iOS or exp build android.

What that does is it actually sends your JavaScript--

your whole bundle, actually-- over to Expo's servers,

The way that you get that build onto your computer is to run this [? ex ?]

[? build ?] [? status, ?] which if you run it while it's building,

it will let you know it's still building.

But once it's done, it will spit out a URL for you,

which is the link to your app in Amazon's S3 storage system.

And then you can just cut and paste that into a browser

Then you can upload it to the appropriate store.

So the way that you do that depends on whether you're doing iOS or Android.

And here's a couple of documentation links

One great thing that you can do with Expo

is to deploy new JavaScript by republishing.

So you actually upload a new bundle because the way that your app works,

it's really just a shell that's running JavaScript code.

And so you can go ahead and download some new JavaScript from the web

And so by republishing from the XDE or using that exp script,

you can deploy a new JavaScript bundle and push it

over the air to your clients without having them redownload

Though if you want to change any application metadata,

like the name of it, then you're going to have to resubmit it to the store.

So doing this over-the-air update thing is very, very powerful,

but also slightly dangerous because you can actually upload JavaScript

And it won't actually be caught by their respective app store people

And then your users go ahead and download that.

And so how do we ensure that everything works as expected before deploying?

And so when we use the word "testing," we generally

are referring to automated testing as opposed

to manual testing or doing quality assurance,

whereby you just open up your app manually and play

with all of the features that you have to make sure

Well, as your application grows in size, manual testing

gets more and more difficult. And more complexity

And so if you imagine if every single week,

you add 10 more features, that's growing linearly every week.

And so even though you keep adding the same number of features every week,

the amount that you have to test every week actually

So you have a linear growth in the number of features

So by adding a test suite, you can ensure that you catch all of your bugs

Because the last thing that you want to do

is actually upload some broken code, because then all of your users

But how do we know which parts of our app to test?

There's this theoretical structure called the test pyramid.

And it determines a methodology for determining test scale or granularity.

So at the very bottom of the pyramid is what's called a unit test.

And this tests an individual unit of code.