Bird
Raised Fist0
React Nativemobile~20 mins

React Native architecture (bridge, new architecture) - Mini App: Build & Ship

Choose your learning style10 modes available
Build: Architecture Overview
This screen shows a simple explanation of React Native's old bridge architecture and the new architecture with TurboModules and Fabric.
Target UI
-------------------------
| React Native Arch      |
|-----------------------|
| Old Bridge:           |
| - JS thread          |
| - Native thread      |
| - Bridge for comm.   |
|                       |
| New Arch:             |
| - TurboModules       |
| - Fabric Renderer    |
| - Direct comm.       |
|                       |
| [Learn More] Button   |
-------------------------
Display two sections: Old Bridge and New Architecture with bullet points
Use simple Text components for explanation
Add a button labeled 'Learn More' at the bottom
When 'Learn More' is pressed, show an alert with a short message about React Native's new architecture
Starter Code
React Native
import React from 'react';
import { View, Text, Button, Alert, StyleSheet } from 'react-native';

export default function ArchitectureOverview() {
  return (
    <View style={styles.container}>
      {/* TODO: Add Old Bridge section */}
      {/* TODO: Add New Architecture section */}
      {/* TODO: Add Learn More button with alert on press */}
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    justifyContent: 'space-between',
  },
});
Task 1
Task 2
Task 3
Solution
React Native
import React from 'react';
import { View, Text, Button, Alert, StyleSheet, ScrollView } from 'react-native';

export default function ArchitectureOverview() {
  const showAlert = () => {
    Alert.alert('React Native New Architecture', 'The new architecture improves performance by using TurboModules and Fabric for direct communication between JS and native code.');
  };

  return (
    <View style={styles.container}>
      <ScrollView>
        <Text style={styles.heading}>Old Bridge:</Text>
        <Text style={styles.bullet}>• JS thread</Text>
        <Text style={styles.bullet}>• Native thread</Text>
        <Text style={styles.bullet}>• Bridge for communication</Text>

        <Text style={styles.heading}>New Architecture:</Text>
        <Text style={styles.bullet}>• TurboModules</Text>
        <Text style={styles.bullet}>• Fabric Renderer</Text>
        <Text style={styles.bullet}>• Direct communication</Text>
      </ScrollView>

      <Button title="Learn More" onPress={showAlert} accessibilityLabel="Learn more about React Native architecture" />
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    padding: 20,
    justifyContent: 'space-between',
  },
  heading: {
    fontSize: 20,
    fontWeight: 'bold',
    marginTop: 10,
    marginBottom: 5,
  },
  bullet: {
    fontSize: 16,
    marginLeft: 10,
    marginBottom: 3,
  },
});

This screen uses simple Text components to show two sections describing the old and new React Native architectures. The old bridge architecture uses a bridge to communicate between the JavaScript thread and native thread. The new architecture improves performance by using TurboModules and Fabric for direct communication.

A Button labeled "Learn More" is placed at the bottom. When pressed, it shows an alert with a short explanation about the new architecture. The layout uses flex and padding for spacing, and a ScrollView to allow scrolling if the content is too tall on small screens.

Accessibility is considered by adding an accessibilityLabel to the button for screen readers.

Final Result
Completed Screen
-------------------------
| React Native Arch      |
|-----------------------|
| Old Bridge:           |
| • JS thread          |
| • Native thread      |
| • Bridge for comm.   |
|                       |
| New Arch:             |
| • TurboModules       |
| • Fabric Renderer    |
| • Direct comm.       |
|                       |
| [Learn More] Button   |
-------------------------
User taps 'Learn More' button
An alert pops up with the message: 'The new architecture improves performance by using TurboModules and Fabric for direct communication between JS and native code.'
Stretch Goal
Add a dark mode toggle that switches the background and text colors between light and dark themes.
💡 Hint
Use React Native's useColorScheme hook to detect system theme or add a switch to toggle a state that changes styles dynamically.

Practice

(1/5)
1. What is the main role of the bridge in React Native architecture?
easy
A. It manages the app's navigation stack.
B. It compiles JavaScript into native machine code.
C. It connects JavaScript code with native platform code.
D. It handles styling and layout of components.

Solution

  1. Step 1: Understand the bridge concept

    The bridge acts as a communication layer between JavaScript and native code in React Native.
  2. Step 2: Identify the bridge's role

    It allows JavaScript to send commands and receive data from native modules, enabling cross-platform functionality.
  3. Final Answer:

    It connects JavaScript code with native platform code. -> Option C
  4. Quick Check:

    Bridge = Connect JS and native [OK]
Hint: Bridge links JS and native code in React Native [OK]
Common Mistakes:
  • Thinking bridge compiles JavaScript
  • Confusing bridge with navigation or styling
  • Assuming bridge handles UI rendering directly
2. Which of the following is the correct way to describe the new React Native architecture?
easy
A. It removes the need for native code entirely.
B. It replaces JavaScript with a new language.
C. It uses a webview to render all components.
D. It improves performance by reducing bridge overhead.

Solution

  1. Step 1: Recall the new architecture goal

    The new React Native architecture aims to make apps faster by optimizing communication.
  2. Step 2: Understand how it improves performance

    It reduces the overhead caused by the bridge, making interactions between JS and native code more efficient.
  3. Final Answer:

    It improves performance by reducing bridge overhead. -> Option D
  4. Quick Check:

    New architecture = less bridge overhead [OK]
Hint: New architecture reduces bridge overhead for speed [OK]
Common Mistakes:
  • Believing it removes native code completely
  • Thinking it replaces JavaScript language
  • Confusing it with webview-based rendering
3. Given the following code snippet, what will happen when the JavaScript calls NativeModules.ExampleModule.getData() in React Native's old architecture?
medium
A. The call is sent over the bridge asynchronously.
B. The call goes directly to native code without delay.
C. The call causes a syntax error in JavaScript.
D. The call is handled by a webview component.

Solution

  1. Step 1: Understand NativeModules call behavior

    In old React Native, calls to native modules go through the bridge asynchronously.
  2. Step 2: Identify the effect of the bridge

    The bridge queues and sends messages between JS and native code, causing asynchronous behavior.
  3. Final Answer:

    The call is sent over the bridge asynchronously. -> Option A
  4. Quick Check:

    Old architecture calls = async bridge [OK]
Hint: Old architecture uses async bridge calls [OK]
Common Mistakes:
  • Assuming direct synchronous native calls
  • Thinking it causes syntax errors
  • Confusing with webview handling
4. You notice your React Native app is slow due to many bridge calls. Which change can help fix this performance issue?
medium
A. Rewrite all JavaScript code in TypeScript.
B. Switch to the new architecture with TurboModules and Fabric.
C. Remove all native modules and use only JavaScript.
D. Use a webview to render the entire app.

Solution

  1. Step 1: Identify cause of slowness

    Many bridge calls cause overhead and slow down the app.
  2. Step 2: Choose the right fix

    The new architecture uses TurboModules and Fabric to reduce bridge overhead and improve speed.
  3. Final Answer:

    Switch to the new architecture with TurboModules and Fabric. -> Option B
  4. Quick Check:

    New architecture reduces bridge calls [OK]
Hint: Use new architecture to reduce bridge calls [OK]
Common Mistakes:
  • Thinking TypeScript improves bridge performance
  • Removing native modules breaks functionality
  • Using webview slows app further
5. How does the new React Native architecture improve UI rendering performance compared to the old bridge system?
hard
A. By using Fabric to directly manage UI components on the native side.
B. By compiling JavaScript into native code at build time.
C. By removing the need for any native code in the app.
D. By rendering UI inside a webview for faster updates.

Solution

  1. Step 1: Understand Fabric's role

    Fabric is the new rendering system that manages UI components natively.
  2. Step 2: Compare with old bridge system

    Old system sent UI updates over the bridge causing delays; Fabric reduces this by direct native management.
  3. Final Answer:

    By using Fabric to directly manage UI components on the native side. -> Option A
  4. Quick Check:

    Fabric improves UI by native management [OK]
Hint: Fabric manages UI natively for speed [OK]
Common Mistakes:
  • Thinking JavaScript is compiled to native code
  • Believing native code is removed
  • Confusing Fabric with webview rendering
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard