DEV Community: Arun Prakash Pandey

REPL means Read, Evaluate, Print, Loop

Arun Prakash Pandey — Fri, 10 Jul 2026 06:07:36 +0000

Why oh why? 😂

Ever wondered, why undefined is logged whenever you're messing around within a Browser's Dev Tools or any other JS run time environment?
Then this is for you!!

node

Welcome to Node.js v22.22.2.

Type ".help" for more information.

> let x = 45;

undefined

> let y = 78

undefined

> x==456 || y==78

true

> console.log(x)

45

undefined

>

TLDR

The output received after evaluation.

The phenomena

The host environment prints the result of every expression.

expression : (x === 456 || y === 78)

prints the result true but no undefined was printed!

However, the statements like below do not return a value.
let x = 45; OR console.log(x)

the above statement did not return any value, causing "undefined" to be printed in the logs.

The cause

Because the host environment is in it's interactive mode.

First, understand that console.log() is not the main purpose here, it is a "side effect".
The main purpose is evaluation of the latest expression. Imagine the REPL environment effectively acting like this behind the scenes:

// 1. it takes your code string (input), 
// 2. evaluates it (via eval()), and 
// 3. returns the result

function executeInREPL(input) {  
  return eval(input);
}

So if you do console.log(x), it would print the value of "x" but since the evaluation did not "return" any value, "undefined" will be logged additionally.

So, the final cause is the result of evaluation.

Things you did not knew about JS- Part-1

Arun Prakash Pandey — Fri, 10 Jul 2026 05:35:39 +0000

When dinosaurs lived:

JavaScript's design was influenced by several programming languages: namely Scheme, Self, Java, C, Perl.

The core language does "NOT" includes:

Read keyboard input
Display output on a screen
Access the file system
Make HTTP requests
Manipulate web pages
Create windows or dialogs These capabilities are provided by the host environment.

Host Environment means the web browser, Or Node.js (a run time "environment").

Host environments provide I/O

Web Browser
- console.log()
- document
- window
- fetch()
- alert()
Node.js
- console.log()
- fs
- http
- process
- readline

Although console.log() is commonly used, it is not part of the ECMAScript specification. It is provided by browsers, Node.js, and other JavaScript environments.

The core language includes:

Numbers (Number, BigInt)
Text (String)
Booleans (Boolean)
Arrays (Array)
Objects (Object)
Sets (Set)
Maps (Map)
Dates (Date)
Regular expressions (RegExp)
Promises (Promise)
JSON
Math utilities (Math)

Most Common Uses

One of Node.js's most common uses is building web servers and APIs.
Node.js is also convenient for writing command-line utilities that automate tasks such as:
- Reading and writing files
- Renaming or organizing files
- Processing CSV or JSON data
- Running build scripts similar to python
- Automating deployments
- Call REST APIs (fetch, http, https)

To be continued...

Things about sorting you need to know

Arun Prakash Pandey — Fri, 03 Jul 2026 17:29:06 +0000

We've all come across various sorting algorithms like bubble sort, merge sort etc whether being new or experienced in programming but sometimes the default sorting is not enough & requires a little tune up, then you need to implement a custom comparison.

This post explores a fundamental property of comparator functions. You'll encounter it whenever you write a custom comparator in JavaScript, especially after discovering that Array.prototype.sort() sorts values lexicographically by default or while solving coding problems on LeetCode for priority queues.
For instance,

//lexicographic comparison converts the values to strings and
 then compares
[10, 2, 5].sort();
// [10, 2, 5] 

//comparator here uses numerical value
[10, 2, 5].sort((a, b) => a - b);
// [2, 5, 10]

The Rule Every Comparator Follows

This is mainly about the underlying comparison principle used when comparing two values and deciding which one to place first and which one to place later.

The comparator decides the relative placement of two values, by

using a 'a certain custom comparison logic' and
communicating that ordering by returning a negative number, zero, or a positive number.

A comparator returns:

a negative value if a should come before b
zero if they are considered equal
positive value if a should come after b

Sorting algorithms do not generally subtract values. However,
Using a - b is simply a convenient implementation for numbers because subtraction naturally produces the required sign.
For an array of objects:

[
  { age: 54, height: 173 },
  { age: 23, height: 180 }
]

Comparison based on age

(a, b) => {
    if (a.age < b.age) return -1;
    if (a.age > b.age) return 1;
    return 0;
}

Comparison based on height

(a, b) => {
    if (a.height < b.height) return -1;
    if (a.height > b.height) return 1;
    return 0;
}

However, the above comparison can be done like this as well:

(a, b) => a.height - b.height;

This works because if a.height < b.height, the subtraction produces a negative result,

indicating that a should be placed before b.

Likewise, a positive result places a **after** b, and
0 means the two values are considered equal for sorting purposes.

Thoughts on implementing a custom Priority Queue in TS

Arun Prakash Pandey — Tue, 16 Jun 2026 07:48:03 +0000

LC 1046

My two cents:

Each push and pop requires a rearrangement of the existing elements, it's almost like the priority queue is a living organism which evolves / devolves it self to maintain the order of the elements.
Swap, BubbleUp, & BubbleDown are the methods doing the main lifting. Here, swap is the simple swap operation
const temp: T = this.heap[i]; this.heap[i] = this.heap[j]; this.heap[j] = temp
The this.compare dependency injection is the soul of the code here. It is the same deciding factor which is used in sorting elements in an array. number < 0, number = 0 & number > 0
where number is the result of a-b or b-a.

bubbleUp and bubbleDown ensure the rearrangement which is required to maintain the order of the elements,
bubbleDown refers to the Pop operation, and bubbleUp refers to the push operation. This is because how they are implemented in the custom heap inside the CustomPriorityQueue class.

Complexity

Time complexity: O(N * log(N)); explanation : Push, Pop has log(N) and Stones array traversal has N.
Space complexity: O(N) for additional priority queue.

Code

function lastStoneWeight(stones: number[]): number {
    const PQ = new CustomPriorityQueue<number>((a, b) => b-a);
    for (let i of stones) {
        PQ.push(i);
    }
    while(PQ.size() > 1){
        const y: number = PQ.pop();
        const x: number = PQ.pop();
        if(y>x){
            PQ.push(y-x);
        }
    }
    // console.log(PQ);
    return PQ.isEmpty() ? 0 : PQ.peak();
};

class CustomPriorityQueue<T> {
    private heap: T[] = [];
    private compare: ((a: T, b: T) => number);

    constructor(compare: (a: T, b: T) => number) {
        this.compare = compare
        // this.heap = [];
    }

    public size(): number {
        return this.heap.length
    }
    public isEmpty(): boolean {
        return this.size() === 0;
    }
    public peak(): T | undefined {
        return this.heap[0]
    }
    private swap(i: number, j: number): void {
        const temp: T = this.heap[i];
        this.heap[i] = this.heap[j];
        this.heap[j] = temp
    }
    public push(value: T): void {
        this.heap.push(value);
        this.bubbleUp(this.size() - 1);
    }
    private bubbleUp(index: number): void {
        while (index > 0) {
            let parentIndex: number = Math.floor((index - 1) / 2);
            if (this.compare(this.heap[parentIndex], this.heap[index]) < 0) break;
            this.swap(parentIndex, index);
            index = parentIndex
        }
    }
    public pop(): T | undefined {
        if (this.isEmpty()) return undefined;
        const top: T = this.heap[0];
        const bottom: T = this.heap.pop();
        if (!this.isEmpty() && bottom !== undefined) {
            this.heap[0] = bottom;
            this.bubbleDown(0);
        }
        return top;
    }
    private bubbleDown(index: number): void {
        const length: number = this.size();
        while (true) {
            let leftChildIndex: number = 2 * index + 1;
            let rightChildIndex: number = 2 * index + 2
            let indexOfSmallestOrLargest: number = index;

            if (leftChildIndex < length && this.compare(this.heap[leftChildIndex], this.heap[indexOfSmallestOrLargest]) < 0) {
                indexOfSmallestOrLargest = leftChildIndex;
            }
            if (rightChildIndex < length && this.compare(this.heap[rightChildIndex], this.heap[indexOfSmallestOrLargest]) < 0) {
                indexOfSmallestOrLargest = rightChildIndex;
            }
            if (indexOfSmallestOrLargest === index) break;

            this.swap(index, indexOfSmallestOrLargest);
            index = indexOfSmallestOrLargest
        }
    }

}

What happened when I used the Web Speech API?

Arun Prakash Pandey — Sun, 12 Oct 2025 11:16:55 +0000

Behind the scene : The Goal...

I wanted to make a web app for my personal use, which involved

Continuously listen to the user’s speech
Convert it to text in real-time
Track the frequency of a specific word (e.g., “Shiv”)
Display that count on screen and store it locally

Simple idea. Surprisingly tricky to implement.

Expectations vs Reality

The app technically worked using the Web Speech API. It listened, transcribed, and returned results. However, instead of processing each word as it was spoken, it:

Listened to full chunks of speech
Waited for pauses or silence
Then returned a batch of words all at once

Even with { continuous: true }, the speech recognition didn’t behave the way I expected — no real-time, word-by-word updates.

Findings

It is not reliable for low-latency, high-frequency word detection

The Web Speech API buffers audio and processes it after short silences.
It often fails to keep up with fast, continuous speech.
Repeating the same word (e.g., "Shiv Shiv Shiv Shiv Shiv") often causes the recognizer to combine or ignore duplicates.

Solution

Stream Audio → Transcribe → Return Text

Use a Cloud-Based Speech-to-Text API
Run an OpenAI whisper STT model on a server locally.
Stream the voice data using a websocket to the backend.
Backend transcribes the speech and sends reponse to the browser.

Result

Understood the limitations of the web speech api and will work on the project with a fresh start.

Install node js ubuntu

Arun Prakash Pandey — Sun, 08 Oct 2023 10:30:29 +0000

This is a guide to installing node js on a Ubuntu machine. You can keep multiple versions of node simultaneously and switch between them as per the requirement.
Follow the below steps for installation :

Run the command ensuring your system is up to date.

sudo apt update

To install the latest stable version, run the command

sudo snap install node --classic

or Visit the Official Snap website to see the list of available versions.

To confirm the installed version of node, run the command

node -v

In case you wish to have more than one version of node installed. Run the command

nvm install v19.9.0

Here v19.9.0 is used as an example and can be replaced by a version of your choice!

To see all the available versions, use the command

nvm list-remote

To see the list of node versions that are installed on your pc, run the command

nvm ls

A similar result to the below image will appear.

To switch between the versions of node, run the command

nvm use v19.9.0

Here v19.9.0 can be replaced with any other version of node that is installed on the system.

Thanks for reading this. I hope this was helpful. Any comments or reactions will be wholeheartedly appreciated.

Updating Discord on Ubuntu

Arun Prakash Pandey — Fri, 06 Oct 2023 11:35:06 +0000

The Discord app does not get updated automatically. Instead, a copy of .deb file is downloaded and the update needs to be installed manually. If you have come across this image

Follow the below simple easy steps :

Download the .deb file
Go to the downloads folder and open the terminal. This is to ensure that you have changed your present working directory!
Type the command sudo apt install ./ make sure to include the .deb file after ./ as shown in the below image.
Hit Enter and it's done. You should see the below result after Hitting enter.

Push, Pop, Shift, Unshift : An Easy way to remember

Arun Prakash Pandey — Wed, 23 Aug 2023 11:22:23 +0000

JavaScript can be confusing in the beginning and this article will help you to easily remember & differentiate between the push(), pop(), shift() and unshift() methods.

Push() and Unshift()-> 'u' is common

The trick is to observe that the letter U is used to spell push and unshift. Hence, they have similar use cases.

For Adding one or more elements in the array.
Returns the length of the new array.
Push() adds elements to the end.
Unshift() adds elements to the beginning.

Now, you know an easier way to remember push() and unshift() methods. The pop and shift can be easily associated with each other.

Pop() and Shift() ->

The trick is to see that unlike push() and unshift() method (where the letter 'u' is common). Nothing is matching here. So, we can keep the pop and shift method in one group. Their use cases are similar as follows:

Both are used for removing.
Returns the item that was removed.
Pop() removes from the end.
Shift() removes from the start of the array.

I hope this helps you to easily remember the methods and their uses.
Feel free to reach out for feedback (good or bad), or just to connect.