Avoiding Memory Leaks in JavaScript

In JavaScript, it's easy to unintentionally create memory leaks and dangling promises, especially when dealing with asynchronous operations. This is often due to the way errors and non-blocking tasks are handled. Unfortunately, the tools available don't address or provide straightforward solutions to these problems.

Let's take a look at an example that illustrates this issue:

function operation_might_throw() {
  // Simulates an operation that may throw an error
  throw new Error("An unexpected error occurred");
}

function long_operation() {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log("This will still log to the console");
      resolve(null);
    }, 1000);
  });
}

async function main() {
  // Start a non-blocking asynchronous operation
  const promise = long_operation();
  // Perform another operation which might throw an error
  operation_might_throw();
  // Await the non-blocking operation
  await promise;
}

What's Happening Here?

In this example:

• operation_might_throw() throws an error, halting further execution of the main function.
• However, the long_operation() continues to run in the background and logs to the console even after the error.
• This happens because the promise is non-blocking and isn't aware of the error in the parent scope.

The Problem

This example demonstrates how easy it is to write memory-unsafe and hard-to-debug asynchronous code in JavaScript. Here, the long_operation() continues to run even though it's no longer needed.

The challenge is: How do we ensure that long-running operations clean up once they're no longer needed? In this case, the cleanup should happen because of an error in the parent scope.

JavaScript's native async/await doesn't provide a straightforward way to handle this scenario. This is where Effection comes in.

---

What is Effection?

Effection is a library that enables structured concurrency in JavaScript, ensuring that asynchronous tasks are managed within a clear and predictable scope.

Rewriting the Example with Effection

Here's how we can rewrite the previous example using Effection:

import { spawn, call, ensure, main } from "effection";

function* long_operation() {
  let timeout: number;

  // Ensure the timeout is cleared, preventing memory leaks
  yield* ensure(() => clearTimeout(timeout));

  const promise = new Promise(resolve => {
    timeout = setTimeout(() => {
      console.log("This will NOT log to the console if an error occurs");
      resolve(null);
    }, 1000);
  });

  // Yield to the promise, allowing other tasks to run
  return yield* call(promise);
}

main(function*() {
  // Start a non-blocking long operation as a child task
  const task = yield* spawn(long_operation);
  // Perform another operation which might throw an error
  operation_might_throw();
  // Await the completion of the child task
  yield* task;
});

What's Different with Effection?

In this version:

• The long_operation() is spawned as a child task using spawn().
• If operation_might_throw() throws an error, Effection automatically cleans up the child task.
• This prevents the console log from occurring, as the long-running operation is canceled.
• ensure() guarantees that clearTimeout() is called, preventing memory leaks.

Why Use Effection?

Effection's structured concurrency model ensures that:

• Asynchronous operations are organized in a predictable hierarchy.
• Child tasks are automatically canceled when the parent goes out of scope (fails or completes).
• Memory leaks and dangling promises are prevented by automatically cleaning up resources.