Hey! Avoid these React Native App Development Blunders


Is React Native A Healthy Investment For Mobile App Development? | Hacker Noon

With over 1.6k active contributors working to make React Native a success, the glitter of a bright framework future has not gone unnoticed by developers looking to make a name in the cross-platform world.

The demand of app development with react native is getting from the developers is not just the doing of the fact that the industry has grown to an extent where it is now comparing Native and React Native modes of development. The demand is also driven by the constant updates that makes the framework advanced.

This demand, though, can only go so far. Ultimately, on a ground level, developers will have to learn their way around the development process. Especially on the front of understanding and avoiding React native app development mistakes which can ruin the users experience and their skills.

We have divided the article into four sections to ease the process of getting accustomed with the errors occured during React Native app development and know what it would take to become a developer that commits minimal mistakes.

Why do Developers Love React Native?

1. Because React Native uses JavaScript

Online javascript tutorial for beginners step by step

JavaScript is one of the languages which a developer starts their career with. And so they have a very detailed resemblance with the subject matter. The fact that React Native relies heavily on JavaScript brings down the learnability curve to a great extent.

2. They get to build native applications

10 Benefits of Native Mobile App Development

Even though the developers work on JavaScript, they don’t use web view for rendering React Native components. The one reason why you should choose React Native is because it renders real native elements, giving developers the flexibility to use platform specific components such as activity indicator, which gives very platform a recognizable, native-like* feel.

*It is impossible for a cross-platform developer to build fully native applications. The difference will be extremely visible on the UI and UX front.  

3. A straightforward installation process

How To Install WordPress | Web development design, WordPress web design, Web design

The installation method must always be direct, i.e. minus any complicated steps. The React Native framework can be installed through the Node Package Manager, which is extremely easy for developers with JavaScript background to follow. And even if you lack the understanding of JS, React Native will prevent you from the hassle of downloading binary from the source.

4. Greater productivity

The Secret to Greater Productivity

The key to building app faster lies in the developers’ productivity levels. While the reliability on JavaScript already makes the process easier, it also comes with a live reload feature and the freedom to use any IDE or text editor of their choice.

5. Strong community backing

Platform Engineering as a (Community) Service

React Native has gained a lot of popularity ever since its launch in 2015. Developers and businesses from all across the globe and industrial background have chosen to go with React Native at the back of the plethora of benefits it offers.

This high demand has in turn resulted in the creation of a strong widespread community working on adjusting the React Native pros and cons on a daily basis.

6. It is truly cross-platform

Best 10 Cross-Platform App Frameworks to Consider in 2020

When we say React Native is a cross-platform app development framework, we don’t just mean using React Native for mobile app development. Using React Native, developers get to expand their skills to smart TVs, smart watches, Windows devices, and even VR headsets.

Even amidst these and several other un-mentioned benefits of React Native development, there are some challenges that inherently come associated with React Native app development. Challenges that experienced developers have come to accept and work around. To eradicate the challenges, wherever you are located, be it Los Angeles, New York, etc, it is advisable to hire a company with app development with react native in New York to build and develop custom react native apps with the latest features.

The thing to note here is that these challenges that you are going to read next in no way imply that we are against React Native. It simply implies that like any other in the process to be perfect framework, there are some prevalent React Native limitations as well. There are in fact, several considerations to be made when developing React Native apps 

Challenges Associated with React Native App Development 

1. Dependency on Native app developers

Android Developers Blog: Native Dependencies in Android Studio 4.0

Noting how JavaScript works, developers sometimes have to rely on native developers as well. Especially when you have to put heavy computational operations in the application. These apps type force developers to offload computation to the native part of app, which in turn requires a native developer.

2. Limitations in Abstraction Layer

Promises and Limitations: Translating Microbiome Research to Practice - AGA Perspectives

In order to add more functionality in the React Native apps, an abstraction layer is added on native platform. Abstraction Layer in itself comes with some persistent issues – the issues to avoid in React Native app development – like:

  • Identifying bugs which gets encountered in the abstraction layer is extremely difficult.
  • High dependency on third-party services and libraries
  • Dependency on implementing custom designs

3. Zero support for multiprocessing or parallel threading

Multithreading VS Multiprocessing in Python | by Amine Baatout | Contentsquare Engineering | Medium

React Native comprises of a single Javascript thread because of which developers might observe slow performances when they want to execute any processes in parallel.

4. iOS deployment is particularly difficult

Apple reimagines the iPhone experience with iOS 14 - Apple

In case of React Native, developers find it particularly annoying when they decide to test their iPhone app on any testing services besides Apple’s Testflight, especially since they will have to deal with issues of obtaining provisioning profiles and necessary certificates.

The process is not very difficult on Android though, as it is very smooth and hassle-free to test and deploy Android apps.

As mentioned before, React Native, like any other framework doesn’t come free of challenges. It ultimately comes down to the experience of the developers. For a newbie or less skilled react native developers these challenges would appear as deal-breakers, while for skilled developers it won’t.

The only difference that stands between a skilled and unskilled React Native developer is the knowledge of mistakes that should be avoided in order to build an error free React Native app.

What makes React Native challenging for some is not just the inherent framework limitations but also the React Native app development mistakes that developers unknowingly commit. 

The 7 Common React Native App Development Mistakes

1. Wrong estimation

Missing the Target - The Friends of Israel Gospel Ministry

  • Layout for iOS and Android version – Yes there will be a number of reusable components, but there could also be different layouts. In fact, the mere structure of an application page can be different on iOS and Android completely.
  • Forms – you should estimate the validation layout as well. When you create app in React Native, you are supposed to write more codes compared to when you create a Hybrid app on suppose Cordova.
  • If creating Web app – You should check all the different endpoints which are offered by the backend. And because you will have to handle the logic in the app, it should all be coded correctly. You should understand the database structure, how the entities are connected, etc.

[ALSO READ: Top Local Databases for React Native App Development {A 2020 List} ]

2. Wrong redux store planning

The only introduction to Redux (and React-Redux) you'll ever need | by Hristijan Stevanoski | JavaScript in Plain English

As a developer when we get an innovative project, we focus more on planning the app layout and less on the data handling part of it.

Redux helps in storing the data correctly and managing, debugging app states. When planned right, it can be a powerful tool for managing the app data. When not, it can mess up many things.

Another point to not in case of Redux app development is that is not extremely suited for small projects. Even small changes will ask you to write long lines of codes. So, it’ll be better if you choose to go with it for large scale applications and avoid it when choosing React Native for startups.

3. Not reading external modules’ codes

Have you tried Pylance for VS Code? If not, here's why you should. | by SJ Porter | Towards Data Science

It is not uncommon for us developers to save time through external modules. It makes things easier and faster, especially since they come with documentation.

But, most often than not, modules break or they might not work as anticipated. This is the reason why developers should read the code and treat the step as one of the React Native best practices. Doing it helps to know what is wrong with the module and even how it can be solved.

4. Mutation of state inside render function

Upgrade/Migrate your Vue 2.x projects to Vue 3.0 | by Jonathan Ma | Medium

The image above highlights how the Datastore and View are interconnected. The datastore contains all your data in component and the view is rendered on the basis of state. It then consumes new state from data store and shows it on the screen.

In order to achieve that, React has a setState() function where the new object state is taken and compared to the previous state.

Finally, a new state is added after merger with the previous state and sent to the state datastore.

This cycle is available all throughout the lifetime of a component when you develop application in React Native.

Now, if you mutate the state directly, the lifecycle gets messed up and it corrupts all the previous states. This leads to app behaving abnormally or even crash. This will also result in you losing track of the states across component and will lead to you writing custom code in place of React. Additionally, you’ll end up having an unmanageable code and a heavy app.

5. Left “console.log” statements

JavaScript Basics: Console.log(). Today we are going to learn the basics… | by Erica N | Level Up Coding

Console log statements are extremely handy. They even provide help with debugging the app execution. But what happens when you leave the log statements in the app?

This can turn out to be a serious issue if you keep the render methods and logics inside, especially those which are asynchronous for they can lead to a bottleneck in JavaScript thread. All this ultimately leads to the application becoming slower.

6. Using stateless component for gaining React Native performance

Stateless Component vs Pure Component | by Vikas Singh | Groww Engineering

Some developers still think that what was true before React 16 is true even now.

Stateless component basically means that the component does not extend any class. It basically takes the argument as display and props in the DOM. It comes with benefits like –

  • Easy testing ability
  • Fast implementation
  • Does not use state or the local variables

With the time changing, it has today become wiser for developers to use pure component when they create React Native apps. Here’s why –

  • Performs shallow compare – This is a special win for complex UI applications as it lowers the render operations. The reason behind it is that it comes with a life cycle method known as shouldComponentUpdate which automatically does shallow comparison and then check if re-render is needed. In case of stateless component, re-render happens when parent component re-renders. But in the case of pure component, re-render only happens when a change is detected in the states or props.
  • Performs side effects – Developers can even send AJAX request inside componentDidmount or can perform some other DOM operations.

7. Not optimizing React Native images

React Native Image Performance. For the second installment of this… | by Adam Stanford | Medium

Optimizing the images in apps built with React Native should be a high priority task. It helps to resize the images locally and then uploading them to cloud storage like the s3 by server and getting the cdn link which then can be returned using API.

Following this process, helps make the image loading process fast.

While these are only 7, there can be a series of others as well. As a developer, your ultimate aim should be to make as few mistakes as possible.

Let us conclude the article by looking into what it would entail to become a developer who doesn’t commit these React Native app development mistakes.

How to Become a Mistakes-Proof React Native App Developer?

First thing first, there is not even a single developer on planet Earth who doesn’t commit mistakes.

Even developers with 10-15 years of experience commit mistakes. Your aim at the end of this article should not be to become a developers who doesn’t commit mistakes. It should be that you don’t commit the React native app development mistakes mentioned in the article and ones which are generally categorized as common in the mobile app development industry.

There are two ways to do that. Ways to become better React Native app developers –

A. Enroll in courses and keep brushing up your skills

Want to brush up your skills? This is how internships can kick-start your career - Education Today News

Enrolling in courses at the beginning of your career can be a great starting point on the present and future grounds.

Brushing up on the skill is equally necessary for when you are skilled and have years of experience. What happens is when you expand your career and work on a variety of projects, you most often than not lose sight of the technical understanding that you started with. Thus, it always comes across as a plus point to get back to the basics and revise things from scratch.

B. Associate with a company that focuses on training

Top 9 Human Resources Training Courses | AIHR Digital

This part is more valid for newbie developers compared to their experienced counterparts. When you are just starting your career you should associate yourself with a mid-sized company that has Team Leaders to hand-hold you through the practical application of what you learned on an academic level.

The reason I say mid-sized company is because a small sized company usually operates in a time crunch model, so will be working under the expectation that you will be on your A game since the day one. Considering this, it will always be better if you partner with a mid-size business who will focus on your learning.

Knowing the mistakes that can ruin the users experience can be a good starting point for developers who take their job seriously. And another good starting point would be to get associated with a mobile app development company that understands how mistakes are a part of learning and helps you grow.

If you are searching for a company in app development with react native in NewYork, California, Texas, and so forth, send in your queries to sales@appinventiv.com.

FAQs about React Native App Development Mistakes to Avoid

How to Write Effective FAQs: Complete With 10 Best Examples

Q. How do you improve react native performance?

There are multiple ways to improve the performance of your React native application:

  • Avoid unnecessary renders
  • Use PureComponent instead of Stateless
  • Optimize the JSON data
  • Lower the app size

Q. Why use Redux with react native?

Redux tool helps in storing  and managing the data, debugging app states. When planned right, it can be a powerful tool for managing the app data. Although considered beneficial, Redux is best suited for the development of complex applications as compared to simple apps, for the number of codes are higher.



ReactJS gains power with Flux

I recently started learning ReactJS. With a very good documentation available on GitHub I found it very easy to learn. I created a sample application in ReactJS & it was working fine!!With some experience in the same I would like to begin by mentioning two of its salient points :

  1. HTML and Javascript in a single file which makes it easy to maintain
  2. Component Driven Development in which DOM is divided into components to make it reusable and easily testable

Then I heard about React with Flux and I was intrigued to know why do we need Flux when React is fine on its own. I did not have much development experience in ReactJS which is why I didn’t realize the power of Flux. Eager to learn, I told myself let’s pull our socks a little, learn Flux and also help train others.

I created an application using ReactJS but initially didn’t use Flux in order to understand its additional benefits like:

  1. Maintainability
  2. Readability
  3. Unidirectional data flow

To see the same in practice, Let’s take a look at developing an application first without using Flux and then using Flux.


Let’s start by understanding basic definition/architecture of Flux –

Flux Architecture

There are four key points to Flux

  1. Action  – Actions are very simple because they only need to take request from View and pass it to the Dispatcher. It acts as mediator between View and Dispatcher.
  2. Dispatcher  – Dispatcher is responsible to pass information to Store. It does that via <this.dispatch> method in dispatcher.
  3. Store – Stores plays with data. It communicates with backend server as per request from View.
  4. View – Views are for displaying information. If views need some information then they get it from Store and if it needs to perform some action or update/add any information then it informs Action.Action calls Dispatcher which in turn fetches data from Store.

React and Flux

Let’s say we have to create a TODO application. It would be a single page application divided into following components

  • Header
    • Todo Count
  • Todo Form
  • Todo List
    • Todo Item

Expected behaviour

  • Todo Count will display the total count of Todo Items.
  • Todo Form will have input field.
  • On submitting the form, new Todo Item should be appended to Todo List and count should be increased in Todo Count.

Application without using Flux

Let’s create a TodoItem Class which will render individual todo item. It will receive information of todo item from its parent component

The below component is TodoList which is responsible for rendering all todo items. This component gets “data” from its parent class via props. “this.props.data” is a list of items which iterates and call TodoItem which we created above.

TodoCount component is responsible to display the count of items. It will get count from TodoHeader component.

TodoHeader component displays the header of an application and it calls the TodoCount component to display the count of total items.

Below is the TodoForm component. Let’s focus on the same because it creates the data in addition to rendering.

The handleSubmit method is called when Submit button is clicked and it calls TodoSubmit method which it got from the Application component.

When I was doing this I had questions –

  •      Why are we doing it this way?
  •      Why Application component submits the form and not TodoForm?

The reason is that Application Component is the parent/grandparent of all components. And data flows from parent to child and child can’t change the state of Parent. Also, there can’t be any communication flow between siblings.

Now if TodoForm will submit the form then how will this information be passed to TodoList or TodoHeader component?

That’s why we made Application component to be responsible for submitting the form.

The Application component is parent of all. It has methods on which we need some discussion.

loadDataFromServer – It will load data from server but in our example there isn’t any server so we have hard coded the data.

handleTodoSubmit – This method would be called by the TodoForm as explained in TodoForm component.

When this method would be called then it will change the state with new created Todo item which will trigger re-rendering of Application component and all child components will be updated with the new information.

As you can see that if sibling components want to communicate with each other then they need to pass data to their parent component.

Like in our example Todo Form wants to tell Todo List that new item has been added.

That’s why Application component is passing callback handleTodoSubmit. So on submit of Todo Form it is calling handleTodoSubmit method of Application component via callback. And handleTodoSubmit is updating the state of Application which causes the re-rendering of Application component by updating Todo Item and Todo Header.

In our example there is only 1 hierarchy but in real time scenarios there could be multi level hierarchy where the innermost child would want to update the other level of innermost child. Then you have to pass the callback method over all the hierarchies.

But that would make it less maintainable and it also impacts readability in negative ways which will result in losing the power of React.

Now Let’s try this same application using Flux

As we have seen there are 4 layers in Flux. Let’s write a code according to its structure.


Actions are called by Views. If View wants to update data in Store then View tells about this changeto Action. Here we have created AppAction. In this, there is only 1 action i.e addItem.

This would be called when we want to add a new todo Item. This action further calls handleViewAction of dispatcher(AppDispatcher)


In AppDispatcher, handleViewAction is defined which is called by AppAction. In handleViewAction action is passed which will tell what action is performed.

There is a this.dispatch inside handleViewAction which is a pre-defined method of Dispatcher. This method will internally call the Store.


Let’s discuss methods of Store one by one.

dispatcherIndex – Execution starts from here because of the AppDispatcher.register. Whenever dispatch method of Dispatcher is called then it would pass the action information wherever AppDispatcher.register is defined.

In our example we have only one action “ADD_ITEM” but in most of the cases there would be multiple actions. So we have to first define the type of action and based on that we will perform actions and will call emit method.

Here, we are calling addTodoItem method from dispatcherIndex method and after that emitChange

addTodoItem – In this method we are not doing anything except pushing new todo item to the todoItems array.

emitChange – In emitChange, we are using this.emit(CHANGE_EVENT) method, this will let listeners of CHANGE_EVENT know that something is changed.

addListener – This method is used by Views to listen to the CHANGE_EVENT.

removeListener – This method is used by Views to remove listener.

getTodoItems – This method will return all the todos. This would be called by TodoList component.

getTodoCount – This method will return the count of all todos. This would be called by TodoCount component.

In TodoList component, we are fetching todo items from Store directly by calling AppStore.getTodoItems in getInitialState.

Now question is how will this component get to know when new todo item has been added?

The answer is in componentWillMount. In this method we are calling AppStore.addChangeListener which will listen to the event whichis defined in addChangeListener of Store. If there would be any change then it will call the _onChange which will reset the state.

Similar to TodoList, TodoCount will also get data from Store and there is a listener defined in componentWillMount.


On comparing both the codes you will find that creating application without using Flux is still easy ? But if you understand the flow of Flux then your choice would always be Flux because flow of Flux would be the same even when your application is getting complex. It provides us with additional benefits of maintainability, readability, unidirectional data flow.

To summerize, lets try again to understand the flow.

In TODO component, we are rendering 3 components <TodoHeader>, <TodoForm>, <TodoList>. There is no need to pass any callback, no need to define any state because <TODO> component is not doing anything except calling other components.

TodoHeader component is also not doing anything except rendering or calling other component.

In TodoCount component, we need to display the count of total items. We will get count from AppStore on rendering of TodoCount. But count may get update after rendering of TodoCount component. That’s why we have added listener in componentWillMount and removed in componentWillUnmount method. So if there would be any update in Store related to count than it would call _onChange method and will change the state of count accordingly.

TodoList component is displaying the list of Todo Items and for that it needs TodoItems. The behaviour is similar to TodoCount in terms of communicating with AppStore.

In TodoForm, we want to submit the form and want to tell other components that new item has been added. So on submit, instead of telling other components it is just passing information to AppAction which will dispatch it to store with the help of AppDispatcher. And AppStore will update/add the data.

In AppStore, there is emit method called in emitChange which will allow listeners to know that information has been updated/added.

As you can see, components are not dependent on each other. If they need any information they will get it from Store and if they want to update anything then they will create an Action and it would be Dispatched to Store.

Clearly, the data flow is unidirectional so it would be easy to understand and maintain.

error: Content is protected !!