¿Por qué estamos aquí hoy?
Básicamente, porque trabajando con VIRGNATIVE,
puedes encontrar que es una tecnología increíble,
y es súper cool, y todo es bastante fácil,
comparado con el plan nativo.
Pero como todo en esta vida,
tiene algunos fallos, ¿verdad?
Entonces, hoy voy a hablar con vosotros
sobre los 9 más comunes Drawbacks
que podrás pasar, probablemente,
trabajando con VIRGNATIVE.
Justamente, Dante ha hecho el mismo viaje
a los 9 CERCOS OF HEAL con Virgil,
que es, bueno, que era él.
Él no es un maestro,
porque nunca conocen en la vida real, obviamente,
pero en esta idea de Dante viajando
alrededor del Inferno,
todo sobre las distancias cronológicas
es un poco suave.
Entonces, conmigo, la idea es que
Dante está construyendo en el Inferno
y Virgil está guardando a él,
y enseñando a él,
y ayudando a él a viajar a cada fase.
¿Qué es el interesante idea
de los CERCOS OF HEAL?
Es que Dante nos dijo
que es un maestro en 9 niveles,
los niveles más altos son más grandes,
y entonces es como un cone.
Y los niveles son cortados por
la dificultad o el dolor que podrás sufrir,
algo así.
Así que es como los solos que se trajan aquí.
Así que, vamos a empezar.
En el inicio, este será el primer nivel.
Hay una escena en el libro,
en caso de que veas,
la comedia divina,
que dice que para el primer nivel,
el único impunición era
estar fuera de Dios.
Entonces, cuando estés en analítica,
en Reignitis,
verás que no es algo doloroso,
verás que es algo que pasa
con tu cuerpo,
que nos vuelve a desplazar.
Y nosotros,
como la detectación automática,
nos llamamos una escena,
y esta verá como una página.
¿Por qué es eso?
Porque no tienes una URL en un móvil.
Y si no tienes una URL,
lo que no tienes ni siquiera,
es el protocolo,
y lo que no tienes ni siquiera,
es el local y el objeto histórico.
Por lo tanto, no hay analítica que puede atrapar lo que estás haciendo y las metadatas de estas cosas.
Entonces, todo es...
Todas las métricas son incluso basadas, que es genial.
Think about mixed panel, por ejemplo.
Segment and the kind of solutions, right?
That would be the first thing.
You don't have automation.
Then, if you want to connect with Rural Analytics, which is something very useful that you have also a website,
because you want to cross the data, right?
Like this user was navigating like that,
and then he jumps to the application and comebacks and whatever.
This is painful, okay?
But there are libraries that makes a cool solution for you.
And it's painful because Rural Analytics is in design to run in a mobile phone, right?
And then, the last thing, you only have very simple solutions.
And what do you mean with that?
Imagine that you want to hook, for example,
I don't know, with the camera sensor, right?
The camera has a sensor for the light that is in the room,
so you can hook easily to this sensor.
You will need to make a bridge connection to the native land,
and the native land send back the events,
and then, with these events, send the metrics.
Where, if you are working with native applications,
the solutions for the kind of things are, well,
they've been here for more time, so they are, like, more mature.
Then, the design, the next wing.
How many of you are ready to work with your native hands up?
Okay, so, for the one that are ready to work with your native,
you will notice that it's, like, super different part of it.
Designing has nothing to do with web,
and the first thing that is super different,
and it's a pain, it's the first pain, is that you don't have hierarchy.
So, you have a view, and you say for the view,
the color, which is red,
and you put a text, as a children, inside the view,
the text won't be red.
You need to tell them again, hey, you're red,
and so on, and so on, and so on.
Hence, you're changing clases, CSS clases,
for object composition, right?
Then you say, I have an object,
which says my color is red,
and this is for the view,
and then I say, for example, my view text extends the color,
and you are passing all the styles,
because there are no classes to every node that needed.
So, here we're changing completely the mindset,
which is important, right?
Because, no, okay, different mindset, sorry.
Which is important, because we have a lot of cool things
that came from the web,
and a lot of years improving our workflows,
so we have very cool SAS,
and they are super well thought,
BEM, and other, not technologies,
but patterns, right, for styling the web,
and everything is based into the class composition.
I have the class, it's flat,
and the class is disabled,
and the class has whatever,
and then I compose into the HTML, everything.
So, here you are changing to object composition,
and they're assigning those styles to every node.
Another thing, we're going very quickly.
The other thing with these styles is the painful debugging,
because, well, Google has a very super cool product,
which is called the Web DevTools, right?
They are inside of Chrome,
and if I go to inspect something,
and I change the color directly,
or put some inline styles,
it will apply automatically, instantly,
and nothing else will change,
or if I want to change a class,
it will change everything directly to the class, right?
So, there is a situation in React Native
that you can do something like that,
which is when you have the hot model replacement working,
which probably, I don't know,
the one person of the developer working with React Native
achieves it, because you need to have,
like, very strict contracts of React Native,
everything should be a class,
everything should be properly extended,
and this is not common.
We use sometimes functional rendering,
or the React Native classes,
or we are using a higher-order component,
so at the moment that you play something like that,
the hot model replacements won't work.
If you have the hot model replacement,
you will go to your source code and say,
this is now 12 instead of 20,
and it will change instantly,
but if you don't have it, you have to reload it again.
So, you are in a process that doesn't persist.
You have to reload again,
you go to the beginning of the process,
you have to click the process all again, right?
This is painful.
And less powerful, why less powerful?
This can be solved with some libraries,
but behind the curtains,
React Native is using a library
that's called Facebook Yoga,
and this is the one in charge of controlling all the styling,
and Yoga doesn't support right now
neither media queries,
neither cell selectors,
neither styles,
like, you know, these things of CSS
that they are not part of the core of CSS,
but you have some libraries that can solve this for you,
but it will be,
well, bad for the performance,
basically because they are hooking to a thing
that's called dimensions and platform from React Native,
and behind the curtains, again,
this is hooking up to the device
for almost all the events of the phone,
so it's not,
well, it won't kill your performance,
but if you're doing something like a video game
or with applications with a lot of animations,
it will be expensive for the phone.
Next, we are still in the ground
of your not suffering too much, right?
Native tools, so here comes the native land.
Native tools and native land,
we're talking about,
I want, for example, use the rendering audits
of Android,
or I want to make some network inspections,
making an inspection of a network,
it's a pain, it's more easy
to go and place a console lock
on the payload.
You will finish earlier.
Or the UI threads,
or the FPS,
so those are tools
that are very common on the native land,
but they quite break
with the JavaScript workflow.
You can use it, of course,
but you need to open up
the Android Studio,
or the Xcode, enable the boogie mode,
if you're with Xcode
and you have everything only with real native,
then you need the provisioning files
for the boogie, and so on.
And I suppose
that you are not using the native tools
with real databases,
because then you move to a
very at the bottom circle.
So manual linking
is the other thing.
This was something common,
but with the new versions
of React Native,
they introduced the React Native link,
it's basically like a
system of templating for the
native files,
so it's easier now,
but there are libraries that doesn't support it
either for the core business of your application
or maybe it doesn't work,
because shit happens, and then you have to
open whatever leader you're using
and go to mess with native code.
So here's the statement.
At the end,
most of the people who's using React Native
or like everyone who's using
React Native,
we're JavaScript developers,
and it's not that easy
to change
to objtc, or java,
or Swift,
but it's another world,
right?
Yeah,
and the hard integration was about
the tools that are linked,
like the one that they mentioned before,
but for example, linked to
events, sensors, orientations,
the kind of stuff that is difficult to use
the native tools from the
JavaScript perspective.
Ha!
Animations.
Okay.
The animations,
now it's a bit of a pain,
because the animations change completely.
Like the design,
the design was a change on the parting,
here it comes again.
For us, most of the animations
are from the CSS perspective,
right, and we make transitions,
because nothing happens,
because the transitions,
right, we are teach
that they are easy
for the GPU and the CPU
to render, so we use it, and they are super cool,
that's fantastic.
But when you move to React Native,
you have a thing that we are going to see right now,
that's called the bridge, okay?
The bridge is the ability.
Why?
Because the bridge is the connection between the
package, is the process
who's running the JavaScript,
and the threads that are running on the
on the phone.
And the bridge is really sensitive
so basically it works like
like a phone call,
right, and you are telling them
some instructions, and sometimes
the bridge is telling you some things
that happen.
You cannot pollute this bridge,
because then the application will go
super slow, and when I mean
super slow, I mean that you want to kill the
FPS completely, even a scroll
will be something difficult to make,
so be aware of the bridge.
Then, what's the solution?
En animations, they make a completely reset
of all the components of React Native,
because when you are going to make
some animations in React Native,
you get the animate or animation
component that basically
is animation.blogging,
dot text, dot scroll view, dot
image, whatever.
And
it works in a declarative
way. So basically
what you are saying is,
so hey, React Native,
here comes an animation.
This animation will start like this
with this value, here comes
the value, and it will finish
like that with this other value.
What does it mean? It means
that you need some mathematical knowledge,
and here comes the problem for most of the
JavaScript developers, because you are
making a thing that's called a polynomial,
right?
So, which is like, if you have a
point here, and another point
here, and another point here, and
for example, a logistic polynomial,
it will make a curve like that,
because it will calculate all the points
in the middle, but I cannot pass
all the time, you are now in 1, 1,
1, 2, 1, 3,
2, 3, right?
I cannot make this, so I make
the polynomial regression, which is
like this position,
for example, this is the thing with
this value, I call it 1,
right? So, it
will finish with an interpolation,
which is another mathematical knowledge.
I don't care about the position,
but the value
instead of 1 will be
3, so it will move up
your view, whatever,
your position
3 times,
right? This is
like the idea that you have.
We are kind of fact,
because we can use things like
animation timing, and you
can hook up to the same time,
when the animation finish, but
this is something that you cannot relate into,
because maybe the UI thread
blocks for some seconds, so
the animation finish later,
or something like that, it happens,
and there is no ACK
and knowledge on the bridge,
so you cannot hook up
to the finish of the animation safely.
You can retry, and there are strategies
to try to make it better,
but you cannot hook up, so
here comes the basic problem
of the bridge, that we are going to see right now.
But first, a note that
they introduce, I
don't remember, but in the 38
or 39,
an extra
component on the API
of React Native, which is called Ising,
and they make, like, the most
common calculations of the interpolation
for us, like the
cubic baser ising in, ising out,
right, just like CSS
at the end, it's another way of making the same.
So,
the bridge.
Here,
the interesting
thing is
to make the symbol in the metaphor
like Dante, because
at the middle of the divine comedy,
Dante faces the gates of the city of this.
For Dante,
it was a
clearly difference between
those who make a scene
passively, and those who make the scene
actively.
So, inside the city of this,
in the lower rings,
is where the
harder punishments
were.
And this is the same.
The bridge, as I told you, is the Abel,
is the performance killer. The bridge
at the end,
how it works, is that you have
your package
and the package automatically
is making some instructions,
right? These instructions,
like, I want
a video, the video needs
a text inside, the text has these
values and these children and whatever.
Those are the instructions.
So, the package says, okay, I'm going to make
JSON and serialize it.
So, because the communication
is really fucked up between the package
and the phone,
the bridge is going to
serialize the JSON
into a string, which is
very dangerous, and send it
to the bridge, to the black box,
which is called the phone.
At this moment, when it goes
to the phone, you cannot
see nothing. You don't see what happens,
if it fails, if it doesn't fail,
if it's done, you don't have
a callback and I don't mean a callback
like a syntax callback. You don't
have an acknowledge, you don't know
when things are done.
So, you cannot hook
to here.
The other problem is that
the phones are designed
like a computer. So, they have a CPU
and the CPU has some threads, right?
So, they work in parallel. This is
the thing, this is how a phone works.
But JavaScript is an
infinite loop. So, to sync
these things, and if I send
an instruction here, and
another instruction, another instruction in JavaScript,
if I send one instruction
and then goes the loop and the loop
cannot catch the next instruction,
we'll get the third instruction and then
we'll catch the second instruction, whatever.
But you cannot do this
against the phone, because
maybe the instructions fail, maybe the second
instruction, the third instruction
needs the second to be done.
So, the communication is synchronous
and all of you know the programs
of synchronous. The performance
is done.
But, and here's
the interesting thing
the
acknowledge, if you
can, if you need and you can
actually make some kind of acknowledge
will be asynchronous, because it will be an event.
The same thing that they
told you, that the package is
making instructions, serializing and sending to the bridge,
the native line
can do the same backwards. They can make
some instructions, serialize it, send it
to the bridge and your package
will get it. And you can hook up
to this, you can make
some listeners, right? In very native, you can make
a very simple listener, like the
upstate, it's actually
the user is using
the app or it's in background, right?
So, this is the phone who's
sending this event to the
package.
So, you are sending
very many, you are sending instructions
that shall be
followed synchronously, but if you want
to hook to them, this is a synchronously.
So, you can break it again
because maybe you have a
listener for an event that needs
an instruction to be done before, but
because it's asynchronous, right?
It's gonna come back
before the other thing. That's why
when you're working with your native, you will notice
that absolutely all the listeners
has the catch
interface.
Because it happens a lot
even for opening
the browser, for example, you make
something like linking, open
URL, and you have the catch at the end
because even this thing
can break up. Because at the end
what is happening down
the other native is
hey, you have a browser, this is one instruction.
Okay, so open the browser, this is another
instruction, and on the ACK
of this instruction, navigate
to this URL. So, if
something is breaking in the middle,
it will fail all the things of
the app browser.
And why is this important?
Because for
90% of the time you will be
developing with your native, you will notice
nothing here. But think about
this. The bridge
for performance reasons, again
can be polluted.
You can send a lot of events
to the bridge, and you can fuck the bridge
and it will be silent.
So you need to continually
make some inspections
of the bridge and know what is happening there.
You can actually
there are a lot of tutorials on the internet
that you can easily find. But you can
actually hook
on the
final function who is sending
the message. And you can see
like very simple console
log or listening the thread
or listening the event, how many messages
are being sent right there.
Right?
And this is like, if you
are going out here with just one
tip, we'll be there. Audit the bridge.
Next.
More pain, testing. And this is important.
Always do testing.
If you don't have testing, your product
isn't finished.
So
the main problem here is that
the testing solutions are very
mature. Because React Native is actually
an immature technology.
You can think
about
two lands here again.
Because the people who
developing with Native applications
they have their own suits for
Android and iOS.
Problem is, again, with the Native tools
they
some sort of
break the JavaScript workflow.
It's very difficult to have some things
tested with JavaScript and then also trigger
some events that they are going to test in blah, blah, blah.
If you think about
the Native land testing, like
another complete suite, that's okay.
Like, for example, end-to-end. A lot of people
is using the suits of Native land
for end-to-end testing.
But they are very difficult to integrate.
And also
you will need to change some
native code, which, as I told you before,
is not that simple.
And the other problem, and the problem
that we are going to focus here is the JavaScript land.
For me, the main problem
and probably for you when you go into
testing in Native applications is that you cannot
manipulate the
DOMs that you are creating, right?
Everything is static.
It's static testing, which
is super painful for the testing,
because basically the only thing that you
can do is a thing that is called shallow render.
Maybe you know about them because
Ensign from Airbnb.
And shallow render at the end, the only thing
that's doing is run this function,
get the result, serialize it,
make a snapshot
or check if something is in there.
But at the end, you are getting a function.
The function will be the render component.
You are getting a JSON.
You cannot change nothing.
You cannot say something like fun or click
or move or nothing like that.
So, the idea is that
when you're working with your React Native applications,
you want to expose
the most components that you can.
So, if you have the typical
Redux container component,
right?
You will have the container very simple
and it's exposed.
The container, not the connected
to Redux function, just the container.
So, I can test the container
and instead of making the manipulations,
like click here, la, la, la,
all these things, I can pass
them different props
every time that they want to test something.
Like a drawer,
like the drawer can have a prop, it's open,
right?
So, I can pass that it's open through.
I will expect that there is a drawer
in the serialized function return
and if I pass it false, I will expect
that this drawer isn't there.
So, this will be the equivalent
to the manipulation testing.
The other problem that you will have,
a React Native application
isn't finished if you didn't test it
in real devices.
Absolutely true.
We, for example, we're working like seven months
trying an iPhone
4, 6, no,
8, 8,
something like that, the small one.
In the emulator was perfect
but when you plug into the real devices
it just simply pop up
and then break down the application.
Today, I still don't know why.
We just change some things
and fix it.
Yeah, for sure.
I mean, it's something weird
I have some clues
but probably the reach was
extremely populated for the CPU
of this phone
because if you didn't know
but when you're using Android
and the Android emulator,
the Android emulator is also emulating
the hardware so you can say
I have only 2 GB of RAM
and so on and so on
but the simulator of Xcode
it goes with the 16 GB
of your Mac computer
no problem, everything is fine.
Let's go.
You need to try real devices
and you cannot fake it.
Real device testing is another pain.
The first one is just connected
because
usually you are virtualizing everything
and this will be the equivalent
like using a phantom GGS
but with a real device.
The phantom at the end, if you are not using headless
it opens a Chrome
application and runs everything in there.
The good thing is that
once you get this connection
properly done,
it's more or less like the simulated one
but it will be painful for sure.
Another thing is
for those used to extreme programming
and the kind of things, continuous delivery
continuous deployment, forget it
because it's impossible
at least for IOS
because they need a manual review
and they cannot do continuous deployment.
You can get to the point
that you submit your application
but then some guy, whatever
it will go to the application, review it manually
and approve it. So, continuous deployment is impossible.
You can do continuous delivery.
You can go for this.
It's okay
though we found out that
the best way to work with the continuous delivery thing
is to automatically push
to test flight for IOS
and Android Beta
for Android
because from the market
you can promote all the testing applications
to production automatically
so at the end it will be like the same
and all your beta testers, maybe
your co-workers at the company or whatever
they can try almost real time
so that's kind of cool
the painful here is that
deployment is impossible
so, work.
Now the tip
there is a thing called code push
you can push changes
to production really without going
through the market processes
note of attention, you cannot change
the intent of the application
you cannot submit a calculator
and we call push changes to a video game
that's not fair
it will ban you
for now it's free
but the people at Microsoft don't think like that
so
don't rely too much
into code push for now, at least
this is my favorite
the router
also the picture
so the router and the 7th circle
which is quite down
if you think about it, they are only 9
it's so painful that even
the Facebook team say that
they won't develop official solution
for the router
because the router is a
very special thing
every app needs
their own router, very customized
and there is no a silver bullet
for this problem
if you go to NPM and search
React Native
you get more than 100 packages
so this is the thing
right now there are two
and they are growing
they are growing strong
they are one from RBMB and the one from Wix
they are cool
and the problem is that
all of them right now
they face the same dichotomy
which is a problem
really fuck up
if you go with Best UX
what you will go is with
navigation experimental
if you are using all versions of React Native
if you are using 40 and beyond
it's deprecated
it was called experimental
so what do you expect
if you go with this
you get a very cool UX
some kind of UI
because everything is declarative
for example you get the gesture
sweeping out
you go back
the titles are ready
crop, everything is fine
it was perfect for the iPad
you can place the buttons on the side
all the things
problems
you want to navigate
for example say you have a Saga
you have Redux connected
and you want to navigate from them
impossible because you only can navigate
through the React context
so the only things that can navigate
are React components
this is very cool when I have a button
but maybe I have nothing crazy
I have a payment process
once the payment process finish
redirect me to the thank you page
impossible
impossible no but the solution is super hacky
ok
yeah
so what's the other
the other part
you have the powerfulness
I like it, I have the router connected to Redux
I can just dispatch an action
and I can navigate whatever they want
I can change the history
or I can render some breadcrumbs
because I have access to my own
history and location objects
right
if I want to connect to a React context
I can do it again, there's no problem
you want the gesture
good luck
because you have to
usually you have a phone
and the phone has a screen and you place the scene
which is the width of the screen
that's cool, you have to have the gestures
from iOS
then you need to place an app shell
which is 3 times the size of your screen
and it's a scroll view but it's locked
so once it's moved, it moves enough
then you have to calculate the pan gesture
recognize it, make your own interpolations
it's back
that's the problem, but you get the Redux scene
it's what my opinion
usually I think the powerfulness is better
because at the end, hooking up a library
to making the animations
and so on, it's easier
and can be done
but on the other hand
this one is completely
hooking to the framework
completely hooking to the framework
you only can navigate from the context
so at the moment that you need
something different, you're trapped
here you can do some sort of things
our application is made
with this approach
and the iOS users, if you try
you will notice that the gesture isn't done yet
but can be done
with a lot of effort, but can be done
in the other way, it's impossible
of course, who say Redux, say mobx
and all the state managers
that you want to use
ok
build tools
this is a problem
that is common
for me it's the only
common point
for the React Native developers
and the native developers
because it's the same pain
to sign an application for iOS
either you are using React Native
or not
how many of you
are ready
to do something
ok, ok, cool
so the idea is that
there are two completely different processes
that's one thing, so you have to learn
two times
the same concept
which is building up an application
one for Android, another one for iOS
the Android one is
kind of simpler
if you have everything well set up
the first time
because it works basically
like
it's an asynchronous code signing
so it works like the
ACH protocol
you have the private key and the public key
it's not called like that, but at the end
you have your bundle identifiers
and you have the key store
and the key store
is like your private key
if you lost the private key store
which is the private key
deploy again to the play store
never
so for us, for example, we have an application
from
2015, right?
something like that, it was like ok
let's make some archaeology
and look on the g-mails for two weeks
until we find the key store
because if not we have to deploy a new application
to the play store, there is no other solution
but
it's kind of easy
then comes iOS
and Apple
wants to handle and control everything
so you have
you have to code signing and for code signing
you need
the developer permission
that comes from an iTunes Connect account
and then you have some provisioning files
to run in a real device
and then you have the pen 12
to sign
the file that you are using to sign in the code
it's complex
there is some hope here
which is called Fastlane
in case you don't know, Fastlane.tools
that you can see
the different approaches from Android and iOS
in there because they have like
ten solutions for iOS
and one or two for Android
so it's something like that
and the tools are like shipping up to beta
so it's nothing
really complex
but it will be
it will be painful
for sure and you need to go again
Fastlane.tools
because you will need to use the Android Studio
and the Xcode and go to the Infoplist
which is the file of configurations
from Xcode and so on
well
at the end we are not used
to that kind of configurations
and maybe the scope says
oh yeah this is called
I don't know the bundle identifier
you know how the bundle identifier
associates to your iTunes Connect
it's a string match
and you fuck it up
and in iTunes Connect you say
oh, it's called Ula Books, it never works
you are done, finish
next
the other problem is versioning
and it's not a problem
like a super technical problem, it's a problem of mindset
because you have the code versioning
the app versioning
the bundle versioning
the iTunes versioning
the Play Store versioning
your own source code versioning
the kind of stuff
well, it's quite complex
and what is the problem
that I bet whatever you want
that you will find yourself
against the screen
in this case a lot of times
because
all those processes
binaries for iOS and APK
for Android, check the build number
at the end of the process
so if you build everything it's ok
perfect, perfect, oh at the end
20 minutos later
you are in the 22 and it's already 22
try again
can you check it before
another problem
with the builders
is that they used to fail
don't worry because they used to fix themselves
again
but they used to fail
if you go to the
the React Native repo right now
and just go to
all the issues
and sort for most commented
the first 5 issues
are about this
like the very famous
CEF bundle identifier
which is an error with 200 comments
because basically you are working one day
po po po po, came the other day
and your xbox doesn't open
solution
un instal, un instal, un instal, un instal
this is the official solution
it's weird
it's weird
and the Facebook team, neither them
they know why this is happening
but we think for the
Facebook guys
they are working really hard
in solving these kind of things
and the new version, well they are improving
these problems
ok, but the test thing is
the final thing because I told you
and I recommend you to
with the call
continuous delivery
to push to the
testing
regions, because it's called test flight for iOS
and Android beta
play beta, I don't know the name
Android beta theme for the play store
probably means the management
again, usually
for iOS for example if you want something
to be on the test flight
the easiest way is that
you have the same domain
email domain
if not you are making an open beta
and the open beta needs special
permissions
if you go to the play store
it's like
super complex to meet the beta
there is no information
anywhere, so you have to be trying
you get a link, if you go to the link
at the first time usually it says
oh no, you are already in the project, but you are not
you have to reload and it works
and I'm not kidding you
this is really how it works
Android beta
is in beta
so it fails
ok, it's cool
we try another approach
that you can think about
especially at the beginning
which is I generate the IPK
for production
and then I push it to the Google Drive
and share the link
because with Android phone
if you don't have an IPK you can install it
no problem
different approach
but at the end you are bypassing the official
market and this is not with the idea at the end
so
let's go to the last one
in the Dante's history
at the end
at the bottom of the inferno
of the hell, it was satanus
it's the place where satanus lives
this is satanus, satanus is a very cool guy
with three faces
and each of the faces is eating
one guy
in the middle is Judas
in case you want some history
upgrade
what do you mean with upgrade
probably, and with very different
the most painful thing with React Native
is upgrading React Native
like you are in the 40
and you want to go to the 43
very difficult
they know that this is very difficult
they develop a special tool
only for do this thing
it uses git
on the back
it's using the git
the algorithm
but what's the problem here
they forget that we are javascript developers
so when you are using this thing
the git upgrade
usually everything goes well
but
all the files that are generated
automatically
by the native LAN
so you go to merge manually
for example
the info pleased
and the generated info pleased
and it's like
if you see some day this file
it's like slash, asterisk
a lot of numbers, hookers, slash
enter, a lot of space
and it's like oh here's a difference
well, I don't know what is this number
it's just a number for real
and it's like yeah, yeah, yeah
merge it manually
I'm sorry
really, I can do that
even Facebook
sometimes they recommend you to
create a new
native application
on the version that you want to
port your code to this new application
because it will be easier
so here's the problem
another thing to be really
aware of
sometimes it's impossible
impossible is a word
that we are not used to
as developers in general
but sometimes it's actually impossible
because you have a strong dependency
that relies into a
lower version
and you cannot update React Native
because this dependency is not ready
so you have two options
don't upgrade React Native
or go to your delivery
make a pull request, change everything you have to change
it will be a pain
then push this to MPM
this happens
this is called the React Native 43 crisis
if you look for it in Google
because they ship 43
depending on React Alpha
16
you can think about how many
libraries
don't support React Alpha
like, I don't know, all of them
so we actually try
and we finish in the 42 because it was impossible
we have
libraries
this is especially problematic with the libraries
that they are hooking up
with the native LAN
like device information
or native events, that kind of stuff
it was simple and impossible
we actually check it, we review
all the pieces of code
and it wasn't possible
so the tip here is
you actually, you really need
to upgrade React Native
maybe you don't
the problem with the 43 crisis
it was that
they talk
before about
they talk about Flatlist a lot
before
they upgrade, they were telling us
Flatlist is amazing, you will
forget
ListView is super cool, super fast
very good performance, so everyone was super excited
to try this new thing
but shit happens
wait for the 45, 46
isn't stable
and the unstable solutions
is just
if you look for
in the internet
for some solutions
about the upgrade thing, you will find out
that even the official ones
are stable, they are still
changing
like they get upgrade
or they are suggesting things like
they create a new application
and port your code to this
so the best thing
you can do for upgrading React Native
just as Dante did
is
be careful
be very careful
so basically
we finish and I want to remember you
that even
that it was a lot of pain in these nine circles
just like Dante
he found that the only way
to the paradise was through the hell
and this is real