DEV Community: Satej Bidvai

Search on steroids: Using regex in VS Code

Satej Bidvai — Tue, 11 Nov 2025 18:21:43 +0000

We've all used Command + Shift + F to search across our codebases. There's a hidden gem here which helps us supercharge our search queries — regex (Regular Expression) search:

Let's take a look at how can leverage regex to:

Find (locate patterns that normal search can't detect)
Find & Replace (Use groups and backreferences in regex to replace patterns)

Scenario 1: Find

Everything a normal text search can do + stuff like:

Find TODO comments mentioning a specific user - \/\/\s*TODO:.*username

Locate all console logs - console\.(log|warn|error)\(
and many more…

Time for an interesting example:

Find incorrect usages of dynamic classes in Tailwind

One day you stumble upon this code:

<div className={`text-${error ? 'red' : 'green'}-600 text-sm`}>...</div>

At first glance, it looks fine — but Tailwind can’t understand it.

Why? Tailwind scans your files for exact string matches like text-red-600, not expressions that dynamically generate class names. It won't see text-${…} at all and those styles will be ignored. (more context)

Here's what the correct code should look like:

<div className={`${error ? 'text-red-600' : 'text-green-600'} text-sm`}>...</div>

Being a good developer, you decide to find and fix all the instances in your codebase… But how !?

Here's what we can do:

Identify the pattern: The problem boils down to finding all classes which contain "-${"(which is a hyphen, followed by template literals).
Use AI to quickly generate a regex - "className=\{[^]*-\$\{[^]*" (Apologies to all the 10x devs, sorry, it's hard to remember the syntax)
Enable regex search (press .* beside your search input) and search. (_I sometimes forget to do this and wonder what went wrong!)

Scenario 2: Find and Replace

When you think about "replacing" text with regex, you may wonder:

How is it possible to replace pattern-matched text correctly?

Say you want to find all function names in your code that start with handle.
You could use this regex: \bhandle\w*\b

This matches words like handleConnect, handleDownload, handleSubmit, etc.

Now, suppose you want to rename all these to start with on instead of handle —
so handleConnect becomes onConnect, handleDownload becomes onDownload, etc.

If you just try replacing everything with "on" or "onDownload", it won’t work.
It’ll overwrite every match with the same thing:

That's not what we want. We need a way to capture and reuse the rest of the word after “handle”.
Let's see how to do that.

Groups and Backreferences in Regex

Groups let us capture parts of a pattern which we can then reuse while replacing our text.
We define a group by wrapping the pattern in a parentheses () .

Here's how we can use this in our example above:

Find: \bhandle(\w+)\b

This captures whatever comes after handle (like Connect, Download, etc.) inside the parentheses.

Replace: on$1

$1 refers to the first captured group — the part matched by (\w+)

(If you had multiple groups, you could access them as $2, $3, and so on)

This is EXACTLY what we wanted!

I hope this was interesting and you found a way to save a teeny-tiny bit of your time which you can now use to scroll reels :)

Why ACID properties matter in database transactions

Satej Bidvai — Tue, 21 Feb 2023 08:31:00 +0000

👋 Hey! You might have come across the term 'ACID properties' in your studies. While it's commonly regarded as a topic to mug up for interviews 😶, there's actually a lot more to understand.

I have tried to provide an overview and touch upon some key concepts that will help you understand the significance of these properties for a database system ⚡️.

What is a Transaction? 💰

A transaction is a group of queries that together make up a unit of work in a database system.
Eg. Transferring funds from one bank account to another.

(Query 1) Deduct money from the source account
(Query 2) Add money to the destination account

Atomicity 🎯

A transaction should be all or nothing - if any part of the transaction fails, the entire transaction should fail and roll back 🚫

Consistency 🤝

The correctness of data should be maintained both before and after a transaction is completed ✅
There are different types of consistency in database systems. Some of them are:
1. Data Consistency: This is the correctness of the actual data stored in the database. The data should follow a set of rules and constraints. This can be achieved via foreign key constraints, unique constraints, data type constraints, etc.
2. Application Consistency: This is the consistency for the application using the database. It refers to the data displayed to the users, data passed between different systems, etc. This ensures that the application’s output is always correct and reliable.
3. Eventual Consistency: Data stored across multiple nodes and servers will eventually have the same value, but may experience temporary inconsistencies. This is because when data is modified, the change needs to be communicated to all copies of the data.

Isolation 🚧

Transactions should be executed in isolation from one another, so that each transaction appears to be the only one executing on the database at a given time 👥
Depending on the isolation level, a transaction may read uncommitted changes which may lead to inconsistencies. Some of these read phenomena are:
1. Dirty Reads: When a transaction reads data that has not been committed yet. This creates a problem when the uncommitted data is rolled back.
2. Non-Repeatable Read: When a transaction reads the same piece of data multiple times and gets different results each time. This may occur due to modification of data between the reads (Unlike dirty reads, the data has been committed).
3. Phantom Read: When a transaction reads rows satisfying a condition (e.g. 100 < balance < 200), but a second transaction inserts or deletes a row that also meets the condition, the result may be inconsistent when the same set of rows is read again.
4. Lost Updates: When multiple transactions attempt to update the same piece of data concurrently, the updates may be overridden and the data may be lost.
To fix these read phenomena, various isolation levels are used in database systems:
1. Read Uncommitted: Transactions can read all changes, even those that have not been committed yet.
2. Read Committed: Transactions can only read committed changes. This solves the “dirty read” phenomena.
3. Repeatable Read: Transactions can read the same piece of data multiple times and get the same results each time. This solves the “non-repeatable read” phenomena, but “phantom reads” may still occur.
4. Snapshot: Transactions read data from a snapshot of the database taken at the start of each transaction. This prevents any modifications by other transactions to be visible in the current transaction. This solves all read phenomena.
5. Serializable: Concurrent transactions are executed in a manner as if they were executed serially, one after the other. This is the highest isolation level.

Durability 💪

The changes made to the database after a successfull transaction should be persisted even in case of system failures 📉
Durability can be achieved by WAL (Write Ahead Logging). In this method, the changes to the database are written into a log file before writing to the disk.
When data needs to be written to a disk, the Operating System (OS) stores it in cache first, then does a bulk write to reduce the number of I/O operations. However, this approach is risky for database systems. To guarantee durability, databases use the fsync() system call, which forces a write to the disk instead of the OS cache.

Using async-await with arr.map()

Satej Bidvai — Thu, 12 Jan 2023 19:25:10 +0000

While working on a task today, I had to populate my array of objects using my database.

Instinctively, I used the map function. The code looked something like this:

const dataList = [
    { type: "test__1" },
    { type: "test__2" },
    { type: "test__3" },
    { type: "test__4" }
];

const modifiedList = dataList.map(async (item) => {
    // Get additional properties from DB
    const dataFromDB = await DataModel.findOne({
        type: item.type
    });

    return { ...item, dataFromDB };
});

❗️ Did you spot the error?

👉🏽 In dataList.map(), we are returning an array of promises and not an array.
👉🏽 Hence, the modifiedList will look something like this:

⚡️ The Solution?

Simple! We just need to wrap our function with await Promise.all so that our array of promises is resolved to the desired modifiedList .

const modifiedList = await Promise.all(
    dataList.map(async (item) => {
        // Get additional properties from DB
        const dataFromDB = await DataModel.findOne({
            type: item.type
        });

        return { ...item, dataFromDB };
    });
);

Operating System Notes for Interviews

Satej Bidvai — Mon, 12 Dec 2022 03:30:42 +0000

These are just for revision and are not exhaustive. You should learn the concepts in depth before following the notes! Do let me know if I have missed any topics :)

Overview

Kernel v/s OS

Kernel: A bridge between the software and hardware of the system.
OS: A system program to provide an interface to the computer user so that they can easily operate on the computer.

Types of OS

Batch Operating System
- An operator takes similar jobs and groups them into batches.
- The next job gets assigned only after the previous job is executed.
Multiprogramming
- When the current job is waiting for I/O, another process is assigned to the CPU.
- The CPU is never idle.
Multitasking / Time-Sharing
- Fixed time slice for different processes.
- Quick response time.
Distributed Operating System
- Remote access is enabled within the network.
- User has access to files not on his system.
Real-Time Operating System
- Complete set of tasks within deadlines.
- eg. Airline traffic control systems

Process Management

Overview

Types of Processing

Preemptive: CPU is allocated to processes for a limited time.
Non Preemptive: CPU is allocated to processes till the process terminates or waits for I/O.

Types of Schedulers

Long Term Schedulers:
- Loads processes from secondary memory to ready queue.
Short Term Scheduler:
- Assigns a process from ready queue to the CPU.
- Selects processes according to a scheduling algorithm.
Mid Term Scheduler
- Swaps process from main memory to secondary memory.
- It can again swap the process to resume execution.

System call: `fork()`

Creates a child process
For ‘n’ fork() calls: 2^n - 1 child processes are created
Returns an integer
- 0: Child Process
- +ve: Parent Process
- -ve: Error; No process created

Context Switching

Saving the context of one process and loading another process.
Allows multiple processes to share CPU.
Interrupts cause CPU to switch to a kernel routine from the current task. (Switch done by OS)

Process v/s Threads

Processes	User Level Threads
System calls	No System calls
Own memory space	Use the memory of parent process
Do no share data or code	Share same copy of code and data
Can be divided into multiple threads	Smallest unit of execution
Blocking one process does not affect the other	Blocking a thread blocks the entire process
Slow context switching	Fast context switching

User Level v/s Kernel Level Threads

User Level Threads	Kernel Level Threads
Managed by user level library	Managed by OS
Fast context switching	Slow context switching
Blocking a thread blocks the entire process	Blocking a thread has no affect on other threads

CPU Scheduling

Key terms

Throughput: The number of processes that are completed per time unit.
Turnaround Time: Sum of the periods spent waiting to get into memory, waiting in the ready queue, executing on the CPU, and doing I/O.
Arrival Time: Time at which a process arrives in the ready queue.
Waiting Time: Sum of periods spent waiting in the ready queue.
Burst Time: Time required for a process to get executed on the CPU.
Completion Time: Time at which a process completes its execution.
Response Time: Time from submission of a request till the first response is produced.

Turn Around Time = Completion Time - Arrival Time

Waiting Time = Turn Around Time - Burst Time

Scheduling Algorithms

First Come First Serve (FCFS)
- The process that requests CPU first is allocated the CPU first (FIFO).
- Non preemptive.
- Avg. waiting time varies substantially according to the burst times of the processes.
- Not ideal for for time-sharing systems.
Shortest Job First Scheduling (SJFS)
- Shortest Next CPU Burst Algorithm
- When the CPU is available, the process that has the smallest CPU burst is assigned first.
- Preemptive or non preemptive
- Preemptive SJFS is also called **Shortest Remaining Time First Scheduling.
- Problems:
  - Knowing the length of next CPU request.
  - Although optimal, cannot be implemented at level of short term scheduling.
  - There is no way to know the length of the next CPU burst.
- We expect the next CPU burst to be similar in length to the previous ones.

3. Priority Scheduling

A priority is associated with each process, and the CPU is allocated to the process with the highest priority.
Equal priority processes are scheduled in FCFS order.
Preemptive or nonpreemptive
Problem of Indefinite Blocking (Starvation)
- Solution: Aging (Gradually increasing the priority of processes that wait in the system for a long time)
Round Robin Scheduling (RR)
- Similar to FCFS scheduling, but preemption is added to switch between processes.
- The CPU scheduler goes around the ready queue, allocating the CPU to each process for a time interval of up to 1 time quantum.
Multilevel Queue Scheduling
- Partitions the ready queue into several separate queues.
- The processes are permanently assigned to one queue, generally based on some property of the process, such as memory size, process priority, or process type.
- Each queue has its own scheduling algorithm.
- In addition, there must be scheduling among the queues, which is commonly implemented as fixed-priority preemptive scheduling.
Multilevel Feedback Queue Scheduling
- Allows a process to move between queues.
- Separates processes according to the characteristics of their CPU bursts.
- If a process uses too much CPU time, it will be moved to a lower-priority queue.
- This scheme leaves I/O-bound and interactive processes in the higher-priority queues.
- In addition, a process that waits too long in a lower-priority queue may be moved to a higher-priority queue.

Processes Synchronization

Interprocess Communication (IPC)

Types of Processes

Independent Process: Do not affect / get affected by other processes.
Cooperating Processes: Affect and get affected by other processes.

Shared Memory

Processes can exchange information by reading and writing to the shared region.
Memory resides in address space of the process creating the shared memory.
Other process that want to communicate must attach this to their address space.

Message Passing

Communication takes place by exchanging messages.
Types of Messages
- Fixed: Easy system level implementation.
- Variable: Complex system level implementation.
Direct Communication
1. Explicitly name the sender or receiver.
  - send(P, message)
  - receive(Q, message)
2. Explicitly naming only the receiver.
  - send(P, message)
  - receive(id, message) : id is set to name of process with which it is communicating
Indirect Communication
- Messages are sent and received from a mailbox.
- Mailbox may be owned by a process or the OS.
- send(A, message) : Send to mailbox A
- receive(A, message) : Receive from mailbox A
Synchronous Communication
- Blocking Send: Sending process is blocked until message is received by the mailbox.
- Blocking Receive: Receiver is blocked until the message is available.
Asynchronous Communication
- Non-blocking Send: Sending process sends the message and resumes operation.
- Non-blocking Receive: Receiver retrieves a valid message or NULL.
Buffers (Queue) can be implemented in 3 ways:
1. Zero capacity: Blocking send
2. Bounded capacity: Blocking send if queue is full
3. Unbounded capacity: Sender is never blocked

Synchronization

Terms

Race Condition: A situation where several processes access and manipulate the same data concurrently and the outcome of the execution depends on the particular order in which the access takes place.

Critical Section Problem

Critical section is a code segment where the shared data can be accessed.

Requirements for solution:

Mutual exclusion: Only one process can access the critical section at any time.
Progress: If a process is not using the critical section, then it should not stop any other process from accessing it.
Bounded waiting: Each process must have a limited waiting time. It should not wait endlessly to access the critical section.

Solution:

Lock Variable
- Executed in user mode.
- Applicable for more than two processes also.
- No gurantee for mutual exclusion.

while (lock == 1);
lock = 1;

// Critical section

lock = 0;

Test and Set Lock
- Satisfies mutual exclusion.
- Does not satisfy bounded waiting.

while(TestAndSet(&lock));

// critical section

lock = false;

boolean TestAndSet(boolean *target) {
        boolean rv = *target;
        *target = true;
        return rv;
}

Turn Variable
- Runs in user mode.
- Applicable only for two processes.
- Strict Alteration (Alternate turns to execute critical section)

while (turn != 0);
// Critical section.
turn = 1;

while (turn != 1);
// Critical section.
turn = 0;

Semaphores

Integer variable used by cooperative processes for synchronization.

Counting Semaphore

-∞ to +∞
Value of semaphore < 0: No. of processes in suspend list

Value of semaphore ≥ 0: No. of processes that can enter critical section

// Entry Code: P / Wait / Down 
Wait(Semaphore S) {
        --S;
        if (S < 0) {
            // Put process in suspend list
        }
}

// Exit Code: V / Release / Up / Signal 
Signal(Semaphore S) {
        ++S;
        if (S <= 0) {
            // Wake one process in suspend list
        }
}

Binary Semaphore (Mutex)

0 / 1

// Entry Code: P / Wait / Down 
Wait(Semaphore S) {
        if (S == 1) {
                S = 0;
        } else {
            // Put process in suspend list
        }
}

// Exit Code: V / Release / Up / Signal 
Signal(Semaphore S) {
        if (<Suspend List is empty>) {
                S = 1;
        } else {
                // Wake one process in suspend list     
        }
}

Deadlock

Necessary Conditions

Mutual Exclusion - At least one resource must be in a non sharable mode; that is only one process at a time can use the resource.
No preemption - A resource can be released only voluntarily by the process holding it, after that process has completed its task.
Hold & Wait - A process holding at least one resource is waiting to acquire additional resources held by other processes.
Circular Wait

In a single instance RAG (Resource Allocation Graph):
- Circular wait ⇒ Deadlock.
- No cycle ⇒ No deadlock.

Methods of prevention

Deadlock Ignorance (Ostrich Method) - Ignore the problem and pretend that deadlocks never occur in the system.
Deadlock Prevention - At least one of the 4 necessary conditions is prevented.
- Mutual Exclusion: Make resources shareable
- No preemption: Allow preemption
- Hold and Wait:
  - Must guarantee that whenever a process requests a resource, it does not hold any other resources.
  - Require process to request and be allocated all its resources before it begins execution.
- Circular Wait: Impose a total ordering of all resource types, and require that each process requests resources in an increasing order of enumeration.
  
  Eg. A process cannot request resource no. 2 after resource no. 3.
Deadlock Avoidance - A decision is made dynamically whether the current resource allocation request will, if granted, potentially lead to a deadlock.

Disadvantages:
- Low device Utilisation
- Reduced system throughput
Deadlock Detection - Deadlock situation may occur. The system may provide:
- An algorithm that examines the state of the system to determine whether a deadlock has occurred.
- An algorithm to recover from the deadlock.
- Banker's Algo (Columns: Allocated, Maximum, Remaining)
Deadlock Free condition:

Total Resources + Total Processes > Total Demand
R > (d1) + (d2 - 1) + ... + (dn - 1)

Memory Management

Terms

Degree of Multiprogramming - The number of processes currently in memory.
Internal Fragmentation - The memory allocated to a process may be slightly larger than the requested memory. The difference between these two numbers is *****internal fragmentation *-** unused memory that is internal to a partition.
External fragmentation - It exists when there is enough total memory space to satisfy a request but the available spaces are not contiguous: storage is fragmented into a large number of small holes.

Memory Management Techniques

Contiguous Partitioning

Fixed Partitioning (Static)
- No. of partitions are fixed.
- Size of each partition may/may not be same.
- Spanning is not allowed.
- Problems:
  - Limit in process size.
  - Limit in degree of multiprogramming.
  - Internal Fragmentation: Diff. between allocated and requested memory.
  - External Fragmentation: Process’s memory request cannot be fulfilled because the memory offered is in a non-contiguous manner.
Variable Partitioning (Dynamic)
- No internal fragmentation.
- No limit in degree of multiprogramming.
- No limit in process size.
- Problems:
  - External Fragmentation - Must use compaction to shift processes so they are contiguous and all free memory is in one block.
  - Allocation/Deallocation is complex.
- Dynamic Partitioning Placement Algorithm
  1. First Fit - Allocate the first hole that is big enough.
  2. Next Fit - Same as first fit but start search from last allocated hole.
  3. Best Fit - Allocate the smallest hole that is big enough.
  4. Worst Fit - Allocate the biggest hole.

Paging

Memory management technique that allows OS to retrieve processes from secondary storage into main memory.

Logical Address = Page No. + Page Size (Offset)
Physical Address = Frame no. + Frame Size

Frame Size = Page Size
No. of entries in page table = No. of Pages
Page Table Entry:

Frame No. Valid(1) / Invalid(0) Protection (RWX) Reference (0/1) Caching Dirty (Modified)
Inverted Paging:

Frame No. Page No. Process ID

Some Important Topics

Thrashing

CPU spends more time swapping or paging activities rather than its execution.

Segmentation v/s Paging

Paging	Segmentation
Invisible to programmer	Visible to programmer
Fixed page size	Segment sizes may vary
Faster	Slower
OS need to maintain list of free frames	OS needs to maintain a list of free holes
Internal fragmentation	External Fragmentation

Overlays

Running a program that is bigger than the size of the physical memory by keeping only those instructions and data that are needed at any given time.
Divide the program into modules in such a way that not all modules need to be in the memory at the same time.
Advantages
- Reduce memory requirement
- Reduce time requirement
Disadvantages
- Overlap map must be specified by programmer
- Overlapped module must be completely disjoint

Important Terms

Zombie Process
- A process whose execution is completed but it still has an entry in the process table.
- Child processes becomes a zombie before being removed from the process table.
Orphan Process : A process whose parent process no more exists i.e. either finished or terminated without waiting for its child process to terminate is called an orphan process.
Cascading Termination: If the parent process is exiting or terminating then the children process will also get terminated.
Starvation
- When a process has not been able to get the required resources it needs for progress with its execution for a long period of time.
- Low priority processes get blocked and only high priority processes are executed.
Aging: To overcome starvation, increase the priority of processes that wait in the system for resources for a long period of time.
Virtual Memory: Storage allocation scheme in which secondary memory can be addressed as though it were part of the main memory.

References

GeeksForGeeks
Gate Smashers - YouTube
Neso Academy - YouTube
InterviewBit
TutorialsPoint

JavaScript for Interviews

Satej Bidvai — Wed, 07 Dec 2022 22:01:45 +0000

This is my first post/blog/article of any sort, so any feedback will be appreciated.

These are my notes which I prepared to revise for JavaScript interviews. Some of the topics are advanced but are a must-know for a intermediate JavaScript developer.

💪 Basics

JavaScript is a dynamically typed language

Data type of variables can be changed during runtime

var justAVariable = 10;
justAVariable = "I am a string now";

/* Does not throw any error */

Variables

	Scope	Can be updated?	Can be redeclared?
var	FUNCTIONAL	YES	YES
let	BLOCK	YES	NO
const	BLOCK	NO	NO

Data Types

Primitive Values

Boolean, String, Number, BigInt, Symbol, Null, Undefined
Objects

Everything except primitives are of type Object in JS.

== v/s ===

== checks only for value (type coersion may occur)
=== checks for both value and type (no type coersion)

Spread Operator

Spreads an array into elements.

Spreads an object into key value pairs.

const arr = [1, 2, 3];
const copyArr = [...arr]; // copyArr = [1, 2, 3]

const sum = (a, b, c) => a + b + c;
sum(...arr); // Equivalent to sum(1, 2, 3)

const obj = { x: 10 };
const copyObj = { ...obj }; // copyObj = { x: 10 }

Rest Parameter

Condense elements into an array.

Function can be called using variable no. of arguments.

const condense = (...params) => {
    return params;
}

console.log(condense(1, 2, 3, 4)); // prints [1, 2, 3, 4]
console.log(condense(1, 2)); // prints [1, 2]

🫡 Array Methods

map() method

arr.map((element, index, array) ⇒ { /* Modify element */ })

/* returns a new array with modified elements */

const numbers = [1, 2, 3, 4];
const double = numbers.map((ele) => ele * 2); // [2, 4, 6, 8]

filter() method

arr.filter((element, index, array) ⇒ { /* Condition */ })

/* returns a new array whose elements satisfy the condition */

const numbers = [1, 2, 3, 4];
const evenNumbers = numbers.filter((ele) => ele % 2 == 0); // [2, 4]

find() method

arr.find((element, index, array) ⇒ { /* Condition */ })

/* returns the first element satisfying the condition */

const numbers = [1, 2, 3, 4];
const greaterThanTwo = numbers.find((ele) => ele > 2); // 3

reduce() method

arr.reduce((prevEle, currEle, currIndex, array) ⇒ { /* Code */ }, initialVal)

/* returns a single value - the accumulated result of calling the callback function on each element */

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((prev, curr) => prev + curr, 0); // 10

☝️ Hoisting

Function, variable and class declarations are moved to the top of the scope.

Variable Hoisting

var is hoisted and initialized with undefined.

console.log(a); // prints "undefined"
var a = 10;

let and const are hoisted, but not initialized.

console.log(b); // ReferenceError: b is not defined
let b = 20;

No hoisting for variables that are not declared.

console.log(c); // ReferenceError: c is not defined
c = 30;

Function Hoisting

Function declarations are hoisted. (! Arrow functions are not hoisted)

helloWorld(); // Works

function helloWorld() {
  console.log("Hello World");
}

Class Hoisting

Class declarations are hoisted, but not initialised.

⚠️ Function and Class expressions are not hoisted.

🤝 Closure

A function and it’s lexical scope together form a closure.
Due to closures, we can access the outer scope of our function.

If we return a function, it stores the reference to variables and functions in the outer scope even after the outer function is executed.

function outerFunc() {
  let str = "Hello World";
    return () => console.log(str);
}

const testClosure = outerFunc();
testClosure(); // prints "Hello World"

/* The returned function still remembers the value of str" */

NOTE: Only a reference to the variables is stored and not the actual value. So, if you mutate the variable before calling the returned function, it will reflect the updated value.

let arr = [];
function outerFunc() {
  arr.push(1);
    return () => console.log(arr);
}

const testClosure = outerFunc();
arr.push(2);
testClosure(); // prints [2, 1]

😮‍💨 IIFE (Immediately Invoked Function Expression)

Do not have a name ⇒ Anonymous function

Executed just after it is defined.

/* Syntax */

( **function(){}** )();
( **function(){}**() );
( **() => {}** )();
!**function(){}**();
+**function(){}**();
-**function(){}**();

Used for keeping data private and exposing selected functions.

const iife = (() => {
  let val = 0;
  return {
    getVal: () => val,
    setVal: (n) => {
      val = n;
    },
  }
})();

iife.setVal(10)
console.log(iife.getVal());

👩‍👦 Prototypal Inheritance

All objects inherit properties with the help of the prototype object.

eg. Arrays inherit from Array prototype
The prototype object has a prototype of it’s own. This forms a prototype chain with the last object being null.
The prototype object: __proto__
When we try to access something in an object, it first checks the object, then in it’s prototype, then in the prototype’s prototype, etc.
```
const arr = [];

arr.push(1); // We can acces this due to the arr.__proto__.push() method
```

👌 Event Loop

A writeup will take too much time to explain 😅
Checkout this video:

What the heck is the event loop anyway? | Philip Roberts | JSConf EU

DEV Community: Satej Bidvai

Search on steroids: Using regex in VS Code

Scenario 1: Find

Find incorrect usages of dynamic classes in Tailwind

Here's what we can do:

Scenario 2: Find and Replace

How is it possible to replace pattern-matched text correctly?

Groups and Backreferences in Regex

Why ACID properties matter in database transactions

What is a Transaction? 💰

Atomicity 🎯

Consistency 🤝

Isolation 🚧

Durability 💪

Using async-await with arr.map()

❗️ Did you spot the error?

⚡️ The Solution?

Operating System Notes for Interviews

Overview

Kernel v/s OS

Types of OS

Process Management

Overview

Types of Processing

Types of Schedulers

System call: fork()

Context Switching

Process v/s Threads

User Level v/s Kernel Level Threads

CPU Scheduling

Key terms

Scheduling Algorithms

Processes Synchronization

Interprocess Communication (IPC)

Types of Processes

Shared Memory

Message Passing

Synchronization

Terms

Critical Section Problem

Deadlock

Necessary Conditions

Methods of prevention

Memory Management

Terms

Memory Management Techniques

Contiguous Partitioning

Paging

Some Important Topics

Thrashing

Segmentation v/s Paging

Overlays

Important Terms

References

JavaScript for Interviews

💪 Basics

JavaScript is a dynamically typed language

Variables

Data Types

== v/s ===

Spread Operator

Rest Parameter

🫡 Array Methods

map() method

filter() method

find() method

reduce() method

☝️ Hoisting

Variable Hoisting

Function Hoisting

Class Hoisting

🤝 Closure

😮‍💨 IIFE (Immediately Invoked Function Expression)

👩‍👦 Prototypal Inheritance

👌 Event Loop

System call: `fork()`