stuck with old version of rn, upgrades break app
new team members onboarding takes forever, environment is extremely tenuous
would i use again? no
11–20 of 149 posts
stuck with old version of rn, upgrades break app
new team members onboarding takes forever, environment is extremely tenuous
would i use again? no
OP, I would like to learn more about your story as well. How did you arrive at your decision that RN is not a good fit?
We tried it for a few months in earnest.
There were a lot of bugs or incomplete APIs for our use-cases. Off the top of my head, if I remember correctly - intricacies and bugs around input handling, the JS navigator implementation didn't properly support swipe back/forward and we could crash it with a couple well timed taps, landscape mode was non-existent, same with master/detail view. We were able to make a few screens in a few days, but polishing them to a shippable standard took exponentially longer or was relatively impossible without doing more native work than what would have been necessary to build it natively from scratch. There were also serious perf issues, like around list views.
Our team members submitted a few PRs to the github repo and they took months to get merged, if at all. Back then it felt like nobody was really at the helm. I suspect this has gotten better since then.
The good (great) part comes from the fact we're a small team (4 devs) and and thus we can do / test / debug things only once for our different platforms (we're using Electron, with all its caveats too).
Apollo and GraphQL availability is also a great plus.
There are performance issues, and data transfer from RN to Native code and the other way is complicated (and different on each platform).
With 30 persons working on an App you've got more than enough to have 1 version for each platform though.
I'd love to know this as well, as we're currently evaluating making the leap between RN and Xamarin for our startup. (ideal world, I favor just using the native stacks for iOS and Android but we are short staffed)
Consider Flutter ( https://flutter.io/ ) as well. The advantage over RN in terms of performances is interesting.
It's missing some polish (notably, check accessibility) https://flutter.io/widgets/accessibility/ "Make your app accessible. (This is a work-in-progress.)"
I haven't dug into how much is done though. It's alpha after all, but I'd be wary of choosing it for a production project at the moment.
1.50 years since app development started 0.75 years since app was released stuck with old version of rn, upgrades break app new team members onboarding takes forever, environment is extremely tenuous would i use again? no
so you have problems you need to sort out with your own codebase. this is not unusual when using any framework. willing to bet this also stems from poor code practices due to the lack of react 'standards' 1.5 years ago / lack of es6+ code
>new team members onboarding takes forever, environment is extremely tenuous
in terms of onbaording, this is something that can always be improved on. better docs. getting started docs. if you've done it once and realized what new hires are struggling with you can reduce that in the future. the environment isn't really that bad, if you had someone who understands javascript ecosystem then they really only need to know how to bundle the packages through the device specific IDE.
just seems like you've got a bad taste in your mouth for a standard everyone else seems to have figured out.
- With a little effort, it genuinely feels native.
- The talent pool is much larger. We didn't hire React Native folk, just good JS people who picked it up quickly.
- Blending native code with JavaScript is easy.
- There are methods to perform app updates without going through the app store release processes of either platform (and waiting for end users to actually download the update).
- It moves quickly, so bugs are squashed pretty quickly, and features arrive at a fast clip.
There have been challenges:
- It moves quickly. Backwards compatibility is doesn't seem to be high on the maintainers priority list, so almost every update will break _something_. We instituted policies of never falling far behind the public release (to avoid needing huge changes at once), and using very few external components (which are often not kept up-to-date with RN).
- If your use cases are outside of the maintainers, there will be problems. The release process seems to be "Does it work for the contributors projects? Ship it". Things like Pod based builds broke for months because they just weren't tested.
- The JavaScript ecosystem is still insane. Our project has ended up with one of the most complex build processes I've worked with (and I've worked with autotools).
My key advice would be:
- Stick with their release cycle, and follow their processes. Don't colour outside the lines, or you will have pain.
- Don't include third party modules unless you have _no other choice_.
- Test on both iOS and Android regularly (i.e. continuously). Things that work well on one platform may be broken on the other.
Based on our outcomes, present me would happily tell past me I'm making a good call, as I'm confident we'd otherwise never have shipped two native-feel applications with 5 developers.
I'd love to know this as well, as we're currently evaluating making the leap between RN and Xamarin for our startup. (ideal world, I favor just using the native stacks for iOS and Android but we are short staffed)
Consider Flutter ( https://flutter.io/ ) as well. The advantage over RN in terms of performances is interesting.
The hardware had a really wimpy SoC, but a native app would never chug for something as simple as pressing a button to change a number.
It made suspect that while in phones with strong GPUs the acceleration makes things buttery smooth, it doesn't graciously scale to poor GPUs (but someone please do correct me if it might have been something else)
It got me worried about shipping an app and finding out it doesn't run on low end hardware even though it doesn't do anything that would be demanding on native
I'd love to know this as well, as we're currently evaluating making the leap between RN and Xamarin for our startup. (ideal world, I favor just using the native stacks for iOS and Android but we are short staffed)
Most teams are committing to native development after trying Xamarin.
I'm part of a JavaScript-only consultancy, we've now built RN apps for three companies in the Fortune 500: a retail, healthcare, and data storage company. Performance-wise, all three applications performed to our clients' standards. However, we also encountered issues concerning debugging, new releases, and other limitations.
That being said, the biggest advantage the RN has (which is why our clients decided to take the plunge) is that it significantly decreases the development time when you want to scale for various platforms. At the end of the day - your decision should be based on you and your team's willingness to play with JavaScript.