DEV Community: Bjorn-Donald Bassey

The point of Memoisation in React

Bjorn-Donald Bassey — Mon, 02 Feb 2026 07:16:21 +0000

You often hear people's advice to React developers to implement memoization by using useMemo or useCallback to improve the performance of your React project. Well, the simplest answer is that it reduces the number of re-renders your application has to make for a React component. But the much longer answer requires an understanding of the heap allocation that happens with your computer's memory. The heap is a body of storage where larger blocks of data can persist with a non-deterministic lifecycle as opposed to the stack, which is usually tied to a function or the main process, where the lifecycle is deterministic (tied to the operation of the function).

While the stack is usually very easy to manage by the CPU, managing data on the heap can be very expensive. This can be divided into:
Allocation of data into blocks of memory,
Deallocation of blocks of memory to free them for other users,
Synchronisation, which manages the ownership and usage of the data within certain memory locations across multiple threads to avoid data races and simultaneous allocation/deallocations,
and fragmentation, which involves breaking apart contiguous blocks of memory to fit data of different sizes. This can lead to a lot of free memory blocks that can’t be used.

What programmers need to understand is that all these operations are costly. The programmer needs to decide when and where these costs occur so they don’t have a negative effect on a user's experience with their application.

How does this relate to JavaScript?
JavaScript can be described as an interpreted language, which means the programmer does not have any control over the allocation or deallocation of the heap. Languages like these have their own garbage collectors as opposed to low-level languages like C or C++. React components are simply functions that re-run. That means those costly heap management operations are also going on each rerun. React will rerender a component when it notices differences in its props, state, or changes in a hook. Every time the React function reruns, every variable or function gets a new memory address, which costs cpu cycles and possibly leads to fragmentation.

But there are some sure-fire ways to avoid unintended memory and CPU usage when building your React project. The keyword is Stable references.

Usually, primitive values like strings, integers, or booleans are compared based on their values, but objects are compared based on their memory addresses. Say you pass an inline function as a prop to a child component like so:

function Parent() { const handleClick = () => console.log("Clicked!"); return <Child onClick={handleClick} />; }
An inline function creates a new memory reference every time it runs. The child component will constantly re-render because the memory address keeps changing. This is the case with variables that are objects in the Component. They will need to get a memory address on the heap every time the component rerenders.

So, useCallback ensures that the memory address of the functions remain thesame between renders unless necessary,

const handleClick = useCallback(() => { console.log("Clicked!");},[])

useMemo maintains a single memory address for objects or arrays between renders unless necessary.

const object = useMemo(() => ({ color: 'blue' }), []);

However, using memoization too much can be detrimental to your project performance due to the amount of resources used for the diff operations

Ref objects are the ultimate strategy for ensuring stability. These are plain JavaScript objects that will retain the same memory address for the whole lifecycle of the component. A change to the ref value (ref.current) doesn’t trigger a re-render.

const ref = useRef(0)

I am on a mission to understand how to get more value from systems with limited memory and compute resources. This was just me relating some things I learnt back to a framework I use frequently at work. I’d love to hear about any bits of knowledge to better understand the frameworks we use.

Find the Maximum Area possible given different vertical lines on X-Axis (Leetcode Problem Analysis)

Bjorn-Donald Bassey — Sat, 04 Oct 2025 14:58:00 +0000

Problem Statement: Given an array with n numbers representing the heights of vertical lines on an x-axis, find the maximum area that can be created with two lines from your array. (Difficulty: Medium)

Input:
An array of integers representing different heights.

Output:
A single integer: the max area.

Solution Approach:

Brute Force Approach:
I first considered testing the area for every pair of values using a shifting center algorithm but that would simply take too long. The time complexity seemed too close to On^2.

Two-Pointer Approach:
So, the strategy was changed to invlove to pointers which will gradually move towards the center of the array while the area is being tested to find the max at each loop iteration. I attempted to halve the number of loop iterations by moving both pointers in each iteration but I getting out of bounds errors. So, I had to reevaluate my solution's requirements.

Optimized Two-Pointer Approach:
I came to the realization that what the solution required was finding the longest lines which were farthest apart as soon as possible, so I decided that to move the pointers based on which value was higher at a loop iteration.

Time complexity: O(n)

Here is the Code in JAVA:

public int maxArea(int[] h) {
        int n = h.length, i=0, max=Integer.MIN_VALUE, a=0,b=n-1;
        if(n==1){
            return h[0];
        }
        while(b>a){
            if(h[a]<h[b]){
                int aa = h[a]*(b-a);
                if(max<aa) max=aa;
                a++;
            } else {
                int aa=h[b]*(b-a);
                if(max<aa) max=aa;
                b--;
            }
        }

        return max;
    }

Supercharging Retrieval-Augmented Generation with NodeRAG: A Graph-Centric Approach

Bjorn-Donald Bassey — Mon, 26 May 2025 04:19:21 +0000

Large Language Models (LLMs) continue to break new ground in complex reasoning tasks. It often feels like a new frontier model tops the leaderboard for reasoning benchmarks every other week. A major contributor to these advancements is the evolution of retrieval mechanisms—particularly those powered by Retrieval-Augmented Generation (RAG).

First introduced by the Meta AI team (Lewis et al., 2020), RAG was designed to improve factual consistency in language model outputs by accessing external corpora during inference. This allows models to deliver more domain-specific, up-to-date, and grounded responses.

Today, tech giants like Google and OpenAI implement RAG differently:

Google’s Vertex AI Search combines semantic and keyword (hybrid) search with a re-ranking mechanism to serve the most relevant results.
OpenAI, on the other hand, embeds RAG directly into the model's runtime when tools and file uploads are enabled. Additionally, OpenAI orchestrates tool usage intelligently with its Responses API.

However, for independent developers and smaller teams, replicating this level of RAG infrastructure is costly. That’s why it’s crucial to explore open-source innovations that democratize access to advanced RAG capabilities.

Enter NodeRAG: a powerful, graph-based RAG framework designed to optimize retrieval by leveraging heterogeneous graph structures. The key contributions of this method can be summarized into three key aspects

What Is NodeRAG?

NodeRAG is a graph-centric RAG framework designed to address limitations in traditional RAG systems, especially when dealing with multi-hop reasoning and summary-level queries.

While earlier graph-based RAG methods showed promise, they often overlooked the design of the graph structure itself. NodeRAG changes that by deeply integrating graph methodologies throughout the indexing and searching process.

At its core, NodeRAG builds a heterograph—a graph made up of different node types, including:

Entities (N)
Relationships (R)
Semantic Units (S)
Attributes (A)
High-level Elements (H)
Overviews (O)
Text Chunks (T)

These nodes form a richly connected structure that encapsulates, summarizes, and enhances the original corpus—leading to fine-grained, context-aware, and explainable retrieval.

NodeRAG Pipeline: From Corpus to Graph

The NodeRAG pipeline is split into two main phases: graph indexing and graph searching.

1. Graph Indexing

This phase constructs the heterograph and enriches it with multiple layers of semantic information.

a. Graph Decomposition

Text is broken down using an LLM into:

Semantic Units (S): Paraphrased summaries of local events or ideas.
Entities (N): Named objects or people.
Relationships (R): Links connecting entities to semantic units.

b. Graph Augmentation

Next, graph algorithms identify key nodes and communities:

Attributes (A) are extracted via LLM summarization of entities and relationships.
High-level Elements (H) are distilled summaries of community-level meaning.
Overviews (O) serve as keyword-based titles for high-level elements.

This step also segments the graph into communities using the Leiden algorithm (Traag et al., 2019), preserving structural coherence.

c. Graph Enrichment

Original text chunks are embedded to retain full context and improve relevance. Only a subset is embedded to optimize for storage and efficiency.

2. Graph Searching

When a query is made, NodeRAG performs a dual-layered retrieval process:

a. Dual Search

Title-based exact match
Vector-based semantic match

b. Personalized PageRank (PPR)

Starting from entry nodes, a shallow PPR algorithm conducts a localized random walk to surface multi-hop reasoning paths, without excessive noise.

c. Final Filtering

Irrelevant or low-value nodes (e.g., keyword-only nodes) are excluded, ensuring a refined and targeted retrieval set.

Evaluation & Benchmarks

NodeRAG has been benchmarked against NaiveRAG, GraphRAG, and LightRAG using datasets like HotpotQA, MuSiQue, and RAG-QA Arena.

when comparing one RAG method against another
"/>

Key Results:

MuSiQue: NodeRAG achieved 46.29% accuracy, outperforming GraphRAG (41.71%) and LightRAG (36.00%).
HotpotQA: NodeRAG delivered comparable accuracy to GraphRAG (89.5% vs 89.0%) with 1.6k fewer retrieved tokens.
RAG-QA Arena (Lifestyle domain): NodeRAG achieved a 94.9% retrieval ratio, compared to GraphRAG’s 86.3% and LightRAG’s 81.7%, with fewer tokens.

These results highlight NodeRAG’s superior efficiency and accuracy, especially in multi-hop and summary-based QA.

Getting Started with NodeRAG

🔧 Requirements

Python
Sample .txt, .md, or .doc files
Anaconda or uv for dependency management
OpenAI API key (GPT-4o-mini recommended)

🧪 Setup & Installation

1. Clone the repository

git clone https://github.com/Terry-Xu-666/NodeRAG.git
cd NodeRAG

2. Create a virtual environment

With Conda:

conda create -n NodeRAG python=3.10
conda activate NodeRAG
pip install -r requirements.txt

With uv (faster):

pip install uv
uv sync
uv pip install -r requirements.txt

3. Prepare your files

Create a project folder with an input/ directory. Add your documents there.

4. Configure NodeRAG

python -m NodeRAG.build -f path/to/project_folder

Edit the Node_config.yaml file:

model_config:
  model_name: gpt-4o-mini
  api_keys: YOUR_API_KEY

embedding_config:
  api_keys: YOUR_API_KEY

5. Build the graph

python -m NodeRAG.build -f path/to/project_folder

6. Run Queries

Create a main.py file:

from NodeRAG import NodeConfig, NodeSearch

config = NodeConfig.from_main_folder("/path/to/project")
search = NodeSearch(config)

ans = search.answer("Create a multiple choice question based on my resume.")
print(ans)

🔍 Visualizing the Graph

Generate an HTML graph with:

python -m NodeRAG.Vis.html -f path/to/project_folder -n 600

This will produce an index.html file you can open in a browser to view a compact visual of your heterograph.

Conclusion

NodeRAG brings a fresh, graph-driven perspective to RAG by integrating semantic, structural, and contextual layers into a single heterograph. Its fine-grained decomposition, explainability, and retrieval efficiency make it a compelling tool for anyone building advanced AI systems without enterprise-level infrastructure.

Whether you're building a personal assistant, a document search engine, or an AI tutor, NodeRAG allows you to create a domain-aware, multi-hop capable retrieval engine—without breaking the bank.

Resources

If you have questions while setting it up, feel free to reach out—I’d love to help.