React Development Bible

Creating a React application is a structured yet creative process that involves several critical steps to ensure that the application is functional, maintainable, and scalable.

WORA: Write Once, Run Anywhere: The world of REACT

React's philosophy is geared towards creating a unified development experience across platforms.
As a development team lead, I can hire only REACT talented developers, not needing to hire (a) web developers, (B) IOS developers, (3) android developers
Let’s dig into the foundational building blocks:
React is a JavaScript library for building user interfaces, primarily targeting web applications. It does not natively interact with hardware features like camera, GPS, or contacts list.
React Native is a separate framework from React, and it's used for building mobile applications that can run on both iOS and Android. React Native code is written in JavaScript and allows access to platform-specific APIs and hardware features, but it does not use Objective-C, Java, or JNDI directly. Instead, it uses a bridge system to communicate with native code when necessary. React Native is a framework that allows developers to build mobile applications using JavaScript and React. One of its most powerful features is the ability to interact with native platform components and APIs. This is where the "bridge" system comes into play.

The Bridge Concept

The bridge is a core part of React Native's architecture that facilitates communication between the JavaScript realm and the native realm. Here's how it works:
The JavaScript realm is where your React Native JavaScript code runs, typically within a JavaScript engine like JavaScriptCore (which is used on both iOS and Android).
The native realm is the part of your app that runs in native code, such as Swift or Objective-C on iOS and Java or Kotlin on Android.
When you're building a React Native app, much of your application logic and UI components are written in JavaScript, but at some point, you might need access to functionality that only native code can provide—like accessing the device's camera or processing gestures at a high frame rate.

Communication via the Bridge

When a React Native app needs to execute native code (such as accessing hardware features or performing an action that requires native APIs), the JavaScript code sends a message across the bridge to the native realm.
The bridge translates this message from the JavaScript thread to the native thread, performs the necessary native operations, and if needed, sends back a response to the JavaScript thread.

Crossing the Bridge: Connecting REACT Library API calls to Device Hardware

The "bridge" in React Native serves as an integral mediator that connects the JavaScript world, where the React library APIs operate, with the native device hardware functionality.
Let's delve into how this connection works, allowing developers to create rich, native applications using the popular React paradigm.

How the Bridge Operates

React Native's bridge system is a bidirectional communication channel that allows JavaScript threads and native threads to send messages to each other. This is how React Native marries the JavaScript code written by developers with the actual native controls and device hardware.

Platform-Specific Bridges in React Native: IOS and Android

The bridge in React Native differs for iOS and Android because it interacts with different native hardware and operation system call environments.
Here's how it works for each platform:
iOS Bridge: On iOS, the bridge connects JavaScript code running in JavaScriptCore (the JavaScript engine that ships with iOS) to the Objective-C or Swift code that interacts with iOS APIs and components. To build and deploy an app for iOS, you would typically need to use a MacOS machine with Xcode installed, as Xcode provides the necessary tooling, simulators, and the ability to sign applications for deployment.
Android Bridge: On Android, the bridge facilitates communication between JavaScript running in JavaScriptCore or Hermes (a JavaScript engine optimized for mobile apps) and the Java or Kotlin code using the Android API and components.
Developers can build and deploy for Android using a variety of operating systems, with Android Studio being the standard development environment.
While the react native bridge allows communication between JavaScript and the respective native languages of each platform, it doesn't mean that developers typically write Objective-C, Swift, Java, or Kotlin code when creating a standard React Native app. Developers call REACT NATIVE Library APIs which do the underlying communications with the target platform hardware memory addresses and Operation System process calls.
Instead, the bridge and the native code that make up the core React Native APIs are already implemented and exposed to JavaScript as modules and components.
Developers call REACT NATIVE Library APIs which do the underlying communications with the target platform hardware memory addresses and Operation System process calls.
React Native abstracts away many of the complexities involved in directly handling platform-specific hardware memory addressing and OS process calls. Let's expand on that:

Abstraction Layer

React Native provides a high-level abstraction layer that allows developers to write JavaScript code that, under the hood, interacts with the platform-specific features and hardware. Developers typically do not need to be concerned with memory addresses or direct system process calls.

React Native Library APIs

The React Native framework's APIs are designed to give developers access to platform-specific capabilities such as the device camera, file system, location services, and other hardware-related functions. When developers invoke these APIs:
React Native translates these JavaScript API calls into corresponding native actions through the React Native bridge, as discussed earlier.
The bridge communicates with native modules that handle the actual interaction with the OS and hardware of the device. It's the native modules that interact with the memory addresses and system processes to accomplish tasks. They expose a JavaScript interface for the React Native environment to interact with.

The Role of the Native Modules

Native modules are platform-specific code pieces (in Objective-C, Swift for iOS, and Java or Kotlin for Android) that React Native invokes as required. They perform tasks by issuing system API calls and can return results back to the JavaScript realm via the bridge.

Operating System & Hardware Communication

Here's what happens when a React Native API is called to interact with hardware:
JavaScript Call: React Native library API is called from the JavaScript code.
Bridge Serialization: The call is serialized and sent over the bridge to the native side.
Native Module Execution: The native module in Objective-C/Swift or Java/Kotlin receives the call, communicates with the OS using native APIs, which in turn interact with the device's hardware.
Response Handling: Any responses or events from the hardware/OS are sent back to the JavaScript side through the bridge, often as serialized data that gets deserialized in the JavaScript realm.

Advantages for Developers

With React Native, developers do not need to be versed in platform-specific languages or hardware interactions. They rely on React Native’s abstraction to handle such communications, allowing them to focus on building the app's logic and user interface. In cases where the built-in React Native APIs do not cover a required functionality, developers do have the option to write their own native modules or use third-party modules to achieve the desired functionality.
In summary, React Native significantly simplifies the process of building cross-platform mobile applications by allowing developers to interact with hardware and system processes through a rich set of pre-made APIs and, when necessary, to extend capabilities through native code.

Writing Native Modules

However, developers can write their own native modules and components when they need functionality that isn't available in React Native's core APIs.
Here's an outline of how this works:
Create Native Module: If, for instance, you are writing a native module for iOS, you would write Objective-C or Swift code that exposes certain functionalities to JavaScript. This might involve creating classes that inherit from RCTBridgeModule and using React Native macros to expose methods to JavaScript.
Use Native Module in JavaScript: Once you have your native module, you call it from your JavaScript code using the NativeModules object provided by React Native. The bridge handles the message passing between your JavaScript code and the native module.
Deploy on Device: To run the app, you would compile the iOS app using Xcode on a MacOS system, which packages the JavaScript code along with the native code into an executable application.
In both iOS and Android development with React Native, the bridge works behind the scenes to abstract away the specifics of each platform, allowing developers to focus more on JavaScript and less on the native side. When developers do need to dig into platform-specific code, they utilize the bridging mechanism to hook into native features from their JavaScript code.


To recap, while the bridge does involve platform-specific implementations, most React Native developers interact with it through high-level APIs rather than writing direct bridge code themselves. Specialized native development is only typically needed when extending React Native's capabilities beyond what is provided out of the box.

Making API Calls from React Native to Device Hardware

When building a React Native application, developers will mostly interact with JavaScript objects and functions provided by React and React Native APIs. However, to handle device-specific operations like accessing the camera, GPS, or accelerometer, they need to send messages across the bridge to native modules that can perform these actions.

The Process of Connecting to Device Hardware

Here's a simplified high-level view of the process:
Invoke Device Capabilities: A React Native component makes a call to a method provided by a native module, such as taking a photo or fetching location data.
Serialization: The JavaScript thread sends the call across the bridge, where it gets serialized into a format that can be efficiently transferred.
Deserialization and Native Execution: The native thread receives the message, deserializes it, and executes the corresponding native function to interact with the device hardware.
Callbacks and Promises: The result of the native operation is often handled by a callback function or a Promise in JavaScript. Once the native thread has completed the operation, it sends back a message over the bridge to JavaScript, which is then turned into a response that the JavaScript code can work with.
Update React Native UI: The state of the React Native app may be updated based on the response from native code, triggering a re-render if necessary to reflect changes in the UI.

Example of a Device Hardware Interaction

Here is a basic example showing how a React Native component might interact with device hardware through the bridge:
import { CameraRoll, Button } from 'react-native';

export default function PhotoSaver() {
const savePhoto = async () => {
try {
// This method invokes a native module method to save an image to the Camera Roll
const savedPhoto = await, { type, album });
console.log('Photo saved', savedPhoto);
} catch (error) {
console.error('Error saving photo', error);

return (
<Button title="Save Photo" onPress={savePhoto} />
In this example, is a method exposed by a native module that communicates with the device's photo storage. When the button is pressed, savePhoto is called, which in turn interacts with the native realm via the bridge to perform the requested action.

Bridging Performance Considerations

While powerful, the bridge system can be a bottleneck due to its asynchronous and serialized nature. Operations performed on the bridge can lead to performance issues if not managed correctly, especially if there is a large volume of data or frequent bridging required.

Future Improvements with TurboModules and the New Architecture

To address these performance concerns, the React Native team is working on the new architecture that includes TurboModules and the JSI (JavaScript Interface).
These improvements aim to streamline the interaction between JavaScript and native code, reduce serialization overhead, and make direct synchronous calls when necessary, leading to more performant interactions with device hardware.
In conclusion, the bridge system in React Native plays a critical role in connecting the high-level React library API calls to the low-level device hardware functionalities, allowing developers to build cross-platform native applications with the same ease and agility as web development.

The messages sent across the bridge are serialized, sent as JSON, and then deserialized on the other side. This means there is some overhead to every single interaction between JavaScript and native code. As such, one of the main considerations in React Native performance is minimizing the number of bridge crossings, or at least making sure that they are efficient and not blocking either thread for long periods.
It's also worth noting that the bridge works asynchronously. JavaScript can send a message to native, or native can send a message to JavaScript, but neither expects an immediate response. This design allows for better performance but requires a different way of thinking about data flow and event handling in your app.

Native Modules and Native Components

Native Modules: You can create your own native modules for parts of your app that need to perform complex calculations, handle sensitive data, or use APIs that are not accessible from JavaScript.
Native Components: Similarly, if there are native UI components that aren't provided by React Native, you can create them yourself and manage their properties, events, and children from JavaScript using the bridge. This allows you to take full advantage of the platform's capabilities and user interface elements.

Evolution of the Bridge

The React Native team is working on a new architecture known as "Fabric" that aims to improve the performance of the bridge system by allowing JavaScript to directly invoke methods in native code without requiring the serialization/deserialization process. This represents a significant step forward in React Native development.
In summary, the bridge system in React Native is a powerful and flexible system that allows you to build high-quality, cross-platform mobile applications using the familiar React paradigm. It's the secret sauce that lets developers enjoy the benefits of writing code once and running it on both iOS and Android, while still being able to tap into the platforms' full capabilities.
The “Write Once, Run Anywhere” philosophy is closely associated with React Native. React (for the web), although very reusable, requires different considerations than React Native when working with device capabilities and rendering.
Now, let's discuss the foundational building blocks:

(1) The React Library of APIs

React is a declarative, component-based JavaScript library for building efficient and flexible user interfaces. It provides a collection of APIs that allow developers to define components as classes or functions. These components can manage their own state using this.state or the useState hook and can receive data from their parent components through props.
Some of the key APIs and features of React include:
React Elements: The smallest building blocks of React apps, representing the description of what to display.
React Components: Independent and reusable bits of code that return React elements from their render method or function body.
State & Lifecycle: APIs that allow components to create interactive and dynamic content by managing the data that changes over time and responding to lifecycle events.
Hooks: Functions that let functional components “hook into” React’s state and lifecycle features (e.g., useState, useEffect).

(2) The React DOM Rendering Library

For web applications, React works alongside ReactDOM, which is a complementary library responsible for rendering components to the DOM (Document Object Model). ReactDOM updates the browser's DOM efficiently by calculating the differences (reconciliation) between the current page and the changes that a component's render output may cause, hence effectively applying the minimal set of changes necessary to update the web page.

React Native and Platform-Specific Code

React Native extends React's philosophy of declarative components to mobile app development, allowing you to write components in JavaScript and render them using native views. It's not written in Objective-C or Java, but provides JavaScript interfaces to access platform-specific native capabilities.
React Native uses a bridge system that allows the JavaScript code to communicate asynchronously with the native code, enabling access to features like the camera, contacts list, etc. Developers use special APIs and components provided by React Native to interact with hardware features and design the user interface using styles that align with the native look and feel on both iOS and Android.

The Unified Development Experience

With React for web development and React Native for mobile applications, development teams can leverage a shared knowledge base in JavaScript and React's design patterns. This does indeed reduce the necessity of hiring specialized web, iOS, and Android developers to some extent, as many skills are transferable between web and native development when using React and React Native.
However, while React and React Native share similar philosophies and some code, they are distinct. Teams often still need expertise in native development for complex tasks and performance optimization, particularly for large-scale and highly customized applications. The React ecosystem is about component reusability and writing declarative code, which provides benefits for maintainability and productivity, but integration with platform-specific features may sometimes require developers familiar with native languages and ecosystems.

How do I fine tune configure Android Studio to be accessible to react native library

my react tutor
To set up Android Studio for React Native development, you'll need to follow a series of configuration steps to ensure the IDE and its tools are properly prepared to build and run your React Native applications.
Here are the main steps you should take to fine-tune your Android Studio setup:

1. Install Android Studio

Download and install Android Studio from the official website: . Follow the installation instructions for your operating system.

2. Install the Android SDK

During installation, make sure you install the latest Android SDK. React Native requires the Android SDK to compile native code.

3. Configure the Android SDK Manager

React Native typically needs the Android SDK Build-Tools, SDK Platforms, and Android Emulator. Ensure you've installed:
The recommended version of the Android SDK Build-Tools. You can find the current recommended version in the React Native documentation or by running react-native doctor.
The appropriate Android SDK Platforms. These are API levels that correspond to different versions of Android. Make sure to install the platforms for the versions you want to target.
The latest version of the Android Emulator to test your app if you don't have an actual Android device handy.

4. Set up the Android Virtual Device (AVD)

Within Android Studio, use the AVD Manager to create and configure an Android emulator. Choose the type of device you want to emulate and the Android version it should run.

5. Configure Environment Variables

Set up important environment variables that allow your system to interact with the Android SDK:
ANDROID_HOME or ANDROID_SDK_ROOT: Point to the location of your SDK. This is automatically set up by Android Studio, but you may need to add it to your shell's profile.
PATH: Update your system PATH with Android SDK's platform-tools directory.

6. Install Java Development Kit (JDK)

React Native also requires Java SE Development Kit (JDK). You can download it from or use OpenJDK. Java version 8 is recommended.

7. Install Watchman (optional)

Watchman is a tool by Facebook for watching filesystem changes. It can help with performance, although it's not strictly required for Android development.

8. Install Node, React Native CLI, and Dependencies

Make sure you have Node.js installed. You'll need it to run the React Native command-line tools.
Install React Native CLI globally using npm:
npm install -g react-native-cli
Install other dependencies, such as Yarn, if you prefer it over npm for package management.

9. Set up your React Native Project

Initialize your React Native project with the react-native init command. After setting it up, you can use Android Studio's terminal or your system's command line to navigate to your project directory and run:
npx react-native run-android
This command will start the React Native bundler and try to compile and launch your app on the emulator or a connected Android device.
By following these steps, you'll configure Android Studio and your environment to be accessible to React Native library and ready for mobile application development. It's essential to refer to the official React Native documentation for any specific tools or versions recommended, as these can change over time.

How do I fine tune configure XCODE to be accessible to react native library

To set up Xcode for React Native development, you need to ensure it is properly configured to work with the tools and components that React Native requires for iOS development. Here are the steps to fine-tune Xcode for React Native:

1. Install Xcode

Download Xcode from the Mac App Store or the Apple Developer website. Make sure that you are installing the latest stable release that is supported by React Native.

2. Install Xcode Command Line Tools

Open Xcode and navigate to "Preferences" > "Locations" tab. Ensure that the Command Line Tools are installed and selected in the dropdown menu. They are necessary for building React Native applications.

3. Agree to Xcode License Agreements

After installation, you may be prompted to agree to Xcode's license agreements. This typically requires opening a terminal and typing:
sudo xcodebuild -license
Follow the prompts to accept the license if required.

4. Install iOS Simulators

To test your React Native app, you'll need to work with simulators that emulate different devices and versions of iOS. These can be installed via Xcode's "Preferences" > "Components" tab.

5. Install CocoaPods

CocoaPods is a dependency manager for Swift and Objective-C projects, which React Native uses for managing library dependencies for iOS applications. Install it by opening a terminal and running:
sudo gem install cocoapods

6. Update Homebrew and Node.js

Make sure you have Homebrew installed and updated. Homebrew is a package manager for macOS, and you will need it to install Node.js and Watchman.
If they are not already installed, use Homebrew to install or update Node.js and Watchman:
brew install node
brew install watchman

7. Set Up Your React Native Project with CocoaPods

Navigate to your React Native project in the terminal and install the iOS project dependencies:
cd ios
pod install
This step ensures all Cocoapods dependencies are installed and linked properly to your Xcode project.

8. Open the iOS Project in Xcode

After running pod install, you can open your React Native project's workspace in Xcode. Look for a .xcworkspace file in your project's ios folder and double-click it to open the project in Xcode.

9. Configure Your Project Settings

Within Xcode, configure the project settings as needed. This includes setting the development team, specifying the bundle identifier, choosing the correct signing certificates, and ensuring the project build settings are correctly set.

10. Run Your React Native Application

You can now run your React Native app in Xcode either through the Product > Run menu command or by pressing the Cmd + R keys. Make sure the desired simulator is selected as the deployment target in the toolbar at the top.
By following these steps, Xcode will be adequately configured to access the React Native library and build and test your mobile application for iOS. Remember to always consult the official React Native documentation for any specific setup requirements that may change with different versions of the framework or development tools.

In the architecture of React applications, components are the fundamental building blocks that define the user interface.

Components in React can be classified into two main categories:

class components

functional components.

Each type of component serves a specific purpose and fits into the overall architecture of a React application in distinct ways.

Class Components: Old School, not the preferred way for new development

Class components are more traditional in React.
They are ES6 classes that extend from React.Component or React.PureComponent and come with additional features such as internal state management and lifecycle methods. These components are particularly useful in scenarios where the component needs to maintain its own state over time, or when it requires access to lifecycle hooks to perform actions at specific points during the component's lifecycle, like setting up a subscription or fetching data upon component mount.
With the ability to encapsulate functionality and manage comprehensive UI behavior, class components play a critical role in React applications that require complex state logic and lifecycle interactions. However, the extensive use of this and the need to bind event handlers in class components can sometimes lead to verbose and less readable code.
Example Usage:
class UserGreeting extends React.Component {
constructor(props) {
this.state = { isLoggedIn: false };
// Lifecycle methods for side effects, data fetching, etc.
componentDidMount() {
// Code to run on component mount
render() {
const { isLoggedIn } = this.state;
return <div>Welcome {isLoggedIn ? 'User' : 'Guest'}</div>;

Functional Components: Today’s Go To Choice for Developers

Functional components are defined as JavaScript functions that return React elements (JSX). Initially introduced as stateless components, the introduction of Hooks in React version 16.8 revolutionized functional components, allowing them to effectively manage state and side effects with useState, useEffect, and other hooks.
This enhancement made functional components as powerful as class components, while also offering a simpler and more concise syntax.
In modern React development, functional components are the go-to choice for creating composable and reusable UI pieces. With less boilerplate than class components, they encourage the development of small, focused, and testable units of UI logic. They integrate seamlessly into React's declarative approach, making code easier to follow and maintain.
Example Usage:
function UserGreeting() {
const [isLoggedIn, setIsLoggedIn] = React.useState(false);
// Hooks for managing state, side effects, context, etc.
React.useEffect(() => {
// Code to run on component mount or update
}, []);
return <div>Welcome {isLoggedIn ? 'User' : 'Guest'}</div>;

Applications in React Architecture

Both class and functional components serve as essential constructs within the React ecosystem, enabling developers to architect applications from a hierarchy of simple to complex components. The decision to use class or functional components can affect the readability, maintainability, and in some cases, the performance of a React application.
React's component-based architecture benefits from the modularity and encapsulation provided by class components, while also embracing the simplicity and compositional nature of functional components. This blend allows for a flexible development environment where components can be seamlessly orchestrated to build sophisticated user interfaces that are both efficient and effective.
As React continues to evolve, the shift towards functional components with Hooks has become more pronounced, reflecting a broader trend in the JavaScript community favoring functional programming paradigms and immutability. Nevertheless, understanding both class and functional components is vital for React developers, as many existing applications and third-party libraries continue to utilize class components extensively.

React Components are the core building blocks of any React application.
They encapsulate behavior and presentation, allowing developers to create complex user interfaces by assembling individual pieces in a modular and maintainable way.
React's component architecture encourages the creation of reusable and composable elements, promoting efficiency and consistency across different parts of an application.

Types of React Components

React components come in two primary flavors: class components and functional components. Both types are capable of displaying content, handling user input, and executing complex rendering logic.
Class Components: Before the introduction of Hooks, class components were the primary means by which developers could use state and lifecycle methods in React. They are ES6 classes that extend from React.Component and provide a rich feature set for managing the component lifecycle, internal state, and handling events. While they are now used less frequently in favor of functional components, they remain a fundamental part of React's heritage and are still prevalent in many existing codebases.
Functional Components: With the advent of Hooks in React 16.8, functional components became as powerful as their class counterparts while maintaining a simpler and more concise form. Functional components are JavaScript functions that return JSX and are typically easier to read and test. They allow developers to use state and other React features, such as context and reducers, via Hooks like useState, useEffect, and useContext.

Component Composition

React is designed around the principle of composition, where smaller components can be combined to create more complex interfaces. This compositional model encourages isolation of individual concerns into separate components, making the code more maintainable and easy to understand.

JSX - The Syntax Extension

In React, components are usually written with JSX, a syntax extension for JavaScript that resembles HTML. JSX enhances the developer experience by making the structure of the component's UI more readable and expressive. Beneath the surface, JSX compiles down to React.createElement() calls, creating a bridge between how the components are authored and how React builds the element tree.

Props and State

Components interact through two key concepts: props and state.
Props: Short for "properties", props are immutable and allow data to flow down from parent to child components. They are akin to function arguments, providing a way for components to be configured and data to be passed between them.
State: In contrast to props, state is mutable and allows components to maintain and manage dynamic information. State changes over time in response to user actions or system events, and changes to the state trigger re-rendering of the component.

Lifecycle Methods and Hooks

Class components make use of special methods called lifecycle methods (e.g., componentDidMount, componentDidUpdate) to run code at particular times in a component's life. Functional components, on the other hand, handle these through Hooks, allowing for side effects, memos, and other lifecycle-related behaviors in a more functional programming style.

Building React Applications

In a typical React application, components range from simple, presentational ones that only render UI to complex, smart ones that manage state and API interactions. By crafting applications via components, React developers can take advantage of the framework's flexibility and powerful features, resulting in highly interactive and responsive web applications.
React Components provide a modern and efficient way to architect web applications. They offer the flexibility to balance form and function seamlessly, paving the way for developers to craft rich user experiences with ease. Whether creating a small widget or an enterprise-level application, React's component model stands as a testament to the power and elegance of component-based architecture in modern web development.
Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
) instead.