IPC communication between processes in Node.js - Mini Project: Build & Apply

IPC Communication Between Processes in Node.js

📖 Scenario: You are building a simple Node.js application where a parent process sends a message to a child process, and the child process responds back. This simulates two processes communicating using IPC (Inter-Process Communication).

🎯 Goal: Create two Node.js scripts: one for the parent process and one for the child process. The parent will send a message to the child, and the child will send a reply back. You will use Node.js's child_process module and IPC channels to achieve this.

📋 What You'll Learn

Create a child process using fork from child_process module

Send a message from the parent process to the child process

Receive the message in the child process and send a reply back

Handle the reply message in the parent process

💡 Why This Matters

🌍 Real World

Many Node.js applications use child processes to run tasks in parallel or isolate work. IPC lets these processes talk to each other safely.

💼 Career

Understanding IPC in Node.js is important for backend developers working on scalable systems, microservices, or tools that require process management.

1

Create the child process script

Create a file named child.js. Inside it, write code to listen for messages from the parent process using process.on('message'). When a message is received, send back a reply message { reply: 'Hello from child' } using process.send().

Node.js

// Your code here to listen for messages and reply

Hint

Use process.on('message', callback) to listen for messages and process.send() to send a reply.

2

Create the parent process script and fork the child

Create a file named parent.js. Import fork from child_process. Use fork to start the child.js script as a child process and save it in a variable called childProcess.

Node.js

const { fork } = require('child_process');

// Your code here to fork child.js

Hint

Use const childProcess = fork('./child.js') to start the child process.

3

Send a message from parent to child and listen for reply

In parent.js, send a message { greeting: 'Hello from parent' } to childProcess using childProcess.send(). Then listen for messages from the child using childProcess.on('message') and save the reply in a variable called childReply.

Node.js

childProcess.send({ greeting: 'Hello from parent' });

// Your code here to listen for reply and save it in childReply

Hint

Use childProcess.send() to send and childProcess.on('message', callback) to receive messages.

4

Complete the IPC communication setup

Add code in parent.js to log the childReply variable inside the childProcess.on('message') callback to confirm the reply was received.

Node.js

childProcess.on('message', (msg) => {
    childReply = msg.reply;
    // Your code here to log childReply
});

Hint

Use console.log() inside the message listener to show the reply.

Practice

1. What does IPC stand for in Node.js context and why is it useful?

easy

A. Internet Protocol Communication; it handles network requests.

B. Internal Process Control; it manages process memory usage.

C. Input-Process-Cache; it speeds up data processing.

D. Inter-Process Communication; it allows processes to exchange messages.

Solution

1. Step 1: Understand IPC meaning and its use in Node.js

   IPC means Inter-Process Communication, which is about processes exchanging data. In Node.js, IPC lets parent and child processes send messages to coordinate work.

2. Final Answer:

   Inter-Process Communication; it allows processes to exchange messages. -> Option D

3. Quick Check:

   IPC = Inter-Process Communication [OK]

Hint: IPC means processes talking to each other [OK]

Common Mistakes:

• Confusing IPC with network protocols
• Thinking IPC manages memory or caching
• Mixing up IPC with internal process controls

2. Which Node.js method is used to create a child process that supports IPC?

easy

A. child_process.spawn()

B. child_process.exec()

C. child_process.fork()

D. child_process.execFile()

Solution

1. Step 1: Review child process methods and identify the one enabling IPC

   spawn(), exec(), execFile() create processes but don't enable IPC by default. fork() creates a child process with an IPC channel for message passing.

2. Final Answer:

   child_process.fork() -> Option C

3. Quick Check:

   fork() creates IPC-enabled child process [OK]

Hint: Use fork() for IPC between parent and child [OK]

Common Mistakes:

• Using spawn() or exec() expecting IPC
• Confusing execFile() with fork()
• Not knowing fork() creates a special IPC channel

3. What will the following code output?

const { fork } = require('child_process');
const child = fork('child.js');
child.on('message', msg => console.log('Parent got:', msg));
child.send('Hello');

// child.js content:
process.on('message', msg => {
  process.send(msg + ' World');
});

medium

A. Parent got: World

B. Parent got: Hello World

C. No output, error occurs

D. Parent got: Hello

Solution

1. Step 1: Trace the message flow and parent's message handler

   The parent sends 'Hello' to child; child appends ' World' and sends back. Parent logs 'Parent got:' plus the message received from child.

2. Final Answer:

   Parent got: Hello World -> Option B

3. Quick Check:

   Child appends ' World' and parent logs it [OK]

Hint: Child appends ' World' before sending back [OK]

Common Mistakes:

• Expecting parent to log original 'Hello' only
• Thinking child does not send a message back
• Confusing message event direction

4. Identify the error in this IPC code snippet:

const { fork } = require('child_process');
const child = fork('child.js');
child.send('Start');
child.on('message', msg => console.log(msg));

// child.js
process.send('Ready');
process.on('message', msg => console.log('Child got:', msg));

medium

A. Parent sends message before child process is ready to receive.

B. Child process sends message before 'message' event listener is set.

C. Child process calls process.send() before parent listens.

D. No error; code works correctly.

Solution

1. Step 1: Analyze message timing and understand child readiness

   Parent sends 'Start' immediately after fork; child may not be ready yet. Child sends 'Ready' immediately but parent may miss it if not listening yet.

2. Final Answer:

   Parent sends message before child process is ready to receive. -> Option A

3. Quick Check:

   Parent must wait for child's 'Ready' before sending [OK]

Hint: Wait for child's ready message before sending [OK]

Common Mistakes:

• Assuming child is ready immediately after fork
• Ignoring asynchronous nature of IPC
• Thinking process.send() order causes error

5. You want to create a Node.js parent process that forks two child processes. Each child sends a number to the parent, and the parent must send back the sum of both numbers to each child. Which approach correctly implements this IPC communication?

hard

A. Parent listens to both children messages, sums numbers, then sends sum to each child using child.send(sum).

B. Each child sends its number to the other child directly using process.send().

C. Parent forks children but does not set up message listeners; children communicate directly.

D. Children send numbers to parent, but parent sends sum only to the first child.

Solution

1. Step 1: Understand parent-child communication and message handling

   Children cannot send messages directly to each other; parent mediates IPC. Parent listens to messages from both children, calculates sum, then sends sum back to each child.

2. Final Answer:

   Parent listens to both children messages, sums numbers, then sends sum to each child using child.send(sum). -> Option A

3. Quick Check:

   Parent mediates and broadcasts sum to children [OK]

Hint: Parent must mediate messages and send sum to all children [OK]

Common Mistakes:

• Trying to send messages directly between children
• Not sending sum to both children
• Not listening to both children's messages in parent