
In Javascript, we have basically two ways to schedule things. One is `setTimeout` and the other is `setInterval`. Suppose you have a scenario where you have to build a Search Autocomplete Component where once the user starts typing you can show thenm some auto-complete result based on the query. Now that seems easy as you can just add a `keyup` listener to the input and you can start firing the request to you backend. Suppose your search component searches for images by querying image description and a user type the query `a man sitting on a bench alone while it's raining` now guesses what will happen. As for every keystroke, we are firing requests and the above query’s length is 48, which means for every average query a search will call around 30 API calls. That’s obviously not very efficient. Isn’t it? So how can we solve the above problem by keeping in mind user experience as well as not making so many API calls? The answer is using `debounce` or using `throttling`. Let’s understand both by taking some examples

## Debouncing

It is a way to decide how often you want a certain function to be called. In debouncing we have a delay parameter. Now when we call our debounced function it fires on the first go but is executed after the delay. Suppose, we have an autocomplete search then what debounced function will do is as we keep typing some query it doesn’t fire any request, while once we stopped typing then after the delay time the request gets fired off. Hence when using search auto-complete suppose a user wanted to search for `laptop 4gb ram 256 ssd`. So when the user types `laptop` and then waits for the delay time then the first API call happens with `laptop`, and then it populates some auto complete result like `laptop i5`, or `laptop 4gb ram`. Then again it follows the same process once the user types some other follow-up query and hence we limit the number of API calls as well as give a good user experience too.

Let’s implement a debounce function now. We should keep in mind that while writing our debounce function we will use the idea of closure to let our debouce function return another function which is debounced and has the delay time passed beforehand. The function signature and the usage is shown below.

```jsx
// the function signature will look like this
function debounce(fn,time) : () => {}

const callApi = () => {
  console.log("api called");
}

const myDebouncedSearch = debounce(callApi,200);

// now we can use our debouncedSearch function by adding it to some event listener or stuff like that
```

After looking at the code snippet you have got some idea what we will be going to do. So without wasting time let’s write our debounce function

```jsx
function debounce(fn, time) {
  let timeoutId = null;
  return function (args) {
    if (timeoutId) {
      clearTimeout(timeoutId);
    }
    timeoutId = setTimeout(() => {
      fn(args);
      timeoutId = null;
    }, time);
  };
}

const callApi = (name) => {
  console.log(name, "called");
};

const myDebouncedSearch = debounce(callApi, 200);
// now we can use our debouncedSearch function by adding it to some event listener or stuff like that
myDebouncedSearch("dog");
myDebouncedSearch("cat");
myDebouncedSearch("rat");
myDebouncedSearch("mat");
myDebouncedSearch("fat");
myDebouncedSearch("bat"); // bat called
```

Now let’s learn about the approach

1. First of all we have to just delay the function call for the given time so we used `setTimeout` for doing the same.
2. Now we have used the idea of closure to inject the delay time through our debounce function and then use it further by passing the arguments needed for the function call.
3. Now as we know in debounce only the last function is get called and all the previous one are get cancelled.
4. So keep a refrence of the function call we assigned our timer to some variable and then we check whether the variable is `null` or it is assigned some value. If there is some value for the timer varibble which is the `timerId` then we know some function is being executed and hence we clear that last function call by calling the `clearTimeout` and let the function call the last called function.
5. Finally we also set the variable storing timeoutId to `null` to preserve the intial state.

That’s all is for debouncing and you can clearly see how useful it is and there are so many usecase for it when we want to limit some function call.

### Throttling

Throttling is also a similar concept which is used to limit function calls. However it has a slight difference, as in case of debounce only the last function gets called, in throttling we call the first function and unless the delay time has passed we execute the next called function. If there afe function calls before the delay time it gets ignored and doesn’t get called. Throttle is useful where some event get called very frequently. Suppose you want to track the user movement on your platoform and you’ve added a `mousemove` event on the view and fire some request based on the mouse move event. But you’ll notice that for tiny mouse movement the event gets called a lot of time. Hence in order to limit the API calls here we can throttle the API call based on some delay time. There are many such other case where you want to throttle the function call to limit certain things. Enough of words now let’s look at some code and implement throttle function.

```jsx
// throttle function
function throttle(fn, time) {
  let timeoutId = null;
  return function (args) {
    if (timeoutId) {
      console.log("cancelled call", args); // added a log for testing
      return;
    }
    timeoutId = setTimeout(() => {
      fn(args);
      timeoutId = null;
    }, time);
  };
}

// for testing

const callApi = (name) => {
  console.log(name, "called");
};

const myThrottle = throttle(callApi, 200);

function simulateFiringEvents(num) {
  let i = 0;
  let interval = setInterval(() => {
    if (i === num) {
      clearInterval(interval);
      return;
    }
    myThrottle(i);
    i++;
  }, 5);
}

simulateFiringEvents(100);
```

Now let’s learn about the approach

1. Here in throttle we check wheter there is timeoutId is not `null`. If it is not `null` then it means there is some function already being called and hence we just return from there without calling the function.
2. Now in the setTimeout we assign the timeoutId to `null` once the function is executed and hence we are able to let new function get called, and the same process goes on limiting subsequent call during the delay time.

This is all for throttling and you can really see how useful it is for various usecases. However there is more better implementation of debounce and throttle in libraries like `lodash` or `underscore` and they handle all the edge cases.

You can look at the source code to get a more cleared idea : [https://github.com/lodash/lodash/blob/master/debounce.js](https://github.com/lodash/lodash/blob/master/debounce.js)

That’s all for today.

If you find this useful please share it or have some suggestion for improvement please react out to me on [Twitter](https://twitter.com/MobashirFarhan).


A brief explanation of debouncing and throttling in JavaScript

Debouncing and Throttling in JavaScript

A quick guide to types and coercion in JavaScript.

Types and Coercion in JS


In computer science, functional programming is a programming paradigm more specifically a declarative paradigm where programs are constructed using functions and composing functions. In functional programming, functions are treated as values that can be passed to other functions as arguments. Languages support like Haskell, Clojure, Elm support functional patterns very well. Javascript, on the other hand, is not really a fully functional language however `functions` in Javascript are first-class citizens and hence we can use it to use functional programming in our code really well.

Functional programming has one simple and main idea of having pure functions which basically means it only takes its input in gives output back irrespective of what having outside of the world.

1. Pure functions don’t have any side effects and to know what is side-effects you can say them as the things which are done not as part of the function return value.
2. Pure functions are deterministic.

**Example of an impure function**

```bash

let name = "Mobashir";
function sayHello() {
  console.log(`Hello ${name}`);
}

sayHello(); // Mobashir
name = "Farhan";
sayHello(); //  Farhan
```

**Example of a pure function**

```jsx
function sayHello(name) {
  return `Hello ${name}`;
}

console.log(sayHello("Mobashir")); // Mobashir
console.log(sayHello("Mobashir")); // Mobashir
console.log(sayHello("Farhan")); // Farhan
```

In both examples, we can see the impure function gives unexpected results due to a change of name variable and hence it has some connection with the outside world, while the pure function just takes the input and gives the same output wherever we call it.

When we are doing functional programming we mostly take care of the computational aspect of the program and not the side effects like making an API call or logging some data to the console or database transaction.

So if we are writing a program in a functional pattern we basically remove all the side effects to the outside of the world and then the remaining part remains pure. This helps us to be a little bit more deterministic about the code and also helps us in unit testing.

**Why Functional Programming?**

1. Functional programs are more deterministic
2. They are a more kind of self-documented
3. They are easy to debug
4. Of course, they will always be easy to unit test and help us in the removal of mocking the program and all the complicated stuff to test our code.
5. Many folks have the notion that the functional paradigm is the best paradigm is not really the case as we know in computer science there is always a tradeoff and we will look at that as we go ahead.
6. Functional programming can be good in a lot of cases like data transformation, or we want to really be certain for some calculation or stuff like that, it is then a good choice.

We should not have our goal to learn functional programming and tend to look smart instead we should learn it in a deeper way which will help us to figure out how to write our code in a more efficient and self-documented way in which we test, debug and ship easily.

### What should we keep in mind while doing functional programming

1. We should do everything with the help of functions.
2. We thinking about writing our program instead of thinking about what my program will do we should think of what my program will take and what it will give back.
3. Functional programming works well with strongly typed data and functions
4. Example of imperative style

```jsx
// imperative style
let name = "John";
let score = 5;

console.log(`${name} scored ${score}`); // John scored 5
score = 10;
console.log(`${name} scored ${score}`); // John scored 10
```

In the above example, we cannot directly tell what are the input here and what are the outputs and we have to see all the imperative commands to actually know the result. However, in the example below let have a look at a more functional approach

```jsx
// functional way
function nameAndScore(name, score) {
  return `${name} score ${score}`;
}

console.log(nameAndScore("Naresh", 10)); // Naresh scored 10
console.log(nameAndScore("Ali", 7)); //  Ali scored 7
```

In the example above we can easily predict the input as well as the output of the program due to these pure functions.

### Recursion

Now we will look at the importance of recursion in functional programming and how it help us to stay out of using loop in our program and being more imperative

In the recursive approach, we will be calling the function from within itself. Here instead of handling state, we will just keep in mind the input that is going in the function and the output going out of the function.

> Iteration doesn’t really go well with functional programming and hence while doing functional programming we should think more about the recursive approach

Let’s compare a function with an iterative approach as well as a recursive approach

**Iterative approach**

```jsx
// iterative approach
function sum(arrayOfNums) {
  let sumTotal = 0;
  for (let i = 0; i < arrayOfNums.length; i++) {
    sumTotal += arrayOfNums[i];
  }
  return sumTotal;
}

console.log(sum([1, 2, 3, 4, 5])); // 15
```

**Recursive approach**

```jsx
// recursive approach
function sum(arrayOfNums) {
  if (arrayOfNums.length === 1) {
    // base case
    return arrayOfNums[0];
  } else {
    // recursive function
    return arrayOfNums[0] + sum(arrayOfNums.slice(1));
  }
}

console.log(sum([1, 2, 3, 4, 5])); // 15
```

While writing recursive functions we should keep two things in our mind:

1. Base Case: In our code the if block is the base case
2. Recursive Case: The else block is the recursive case
3. Recursion doesn’t ensure the function is a pure function.

**Let’s take another example of the recursive approach and iterative approach**

Iterative Fibonacci Sum

```jsx
// recursive approach
function iterativeFibonacci(n) {
  if (n === 0) {
    return 0;
  }
  if (n === 1) {
    return 1;
  }
  let previous = 0;
  let current = 1;
  for (let i = n; i > 1; i--) {
    let next = previous + current;
    previous = current;
    current = next;
  }
  return current;
}

console.log(iterativeFibonacci(10)); // 55
```

Recursive fibonacci sum

```jsx
// recursive approach
function recursiveFibonacci(n) {
  if (n === 0) {
    return 0;
  }
  if (n === 1) {
    return 1;
  }
  return recursiveFibonacci(n - 2) + recursiveFibonacci(n - 1);
}

console.log(recursiveFibonacci(10));
```

**Problems with recursion**

1. Many times we do the same calculation over and over again and the solution to this is memoization.
2. The second problem is the stack overflow when calling the recursive function with very large number like in Fibonacci and the solution to that is tail call recursion. It is a thing in js runtime that if we write our recursive function in a particular way it does optimization for us.
3. When doing recursion we are playing with call stack and hence debugging it is a little bit complicated.
4. Only safari supports tail call optimization properly. Chrome and V8 don’t.

### Higher Order Function `map`,`filter`,`reduce`

Javascript has a first-class function which means we can pass a function as the arguments to other functions.

Higher order functions are the functions that take in other functions as input. We will use higher-order functions more while working with functional programming in javascript. They are also the alternative to loop

All these `map`,`filer`,`reduce` are array methods and they work on the array.

1. Filter filters something from an array base on some condition.
2. Map takes an array and do some operation and then returns the operated array.
3. Reduce take an array and reduce it to one single value or some accumulated value.

**Let's learn more about these functions:**

1. Map and filter don’t mutate the array and can be called a pure function but your callback doesn’t ensure to be a pure function and it can have impurities.

### Filter

let us write our own basic filter function.

```jsx
function myFilter(array, cb) {
  let returnArr = [];
  array.forEach((item) => {
    if (cb(item)) {
      returnArr.push(item);
    }
  });
  return returnArr;
}

function isEven(item) {
  if (item % 2 === 0) {
    return true;
  } else {
    return false;
  }
}

function isGreaterThan5(item) {
  if (item > 5) {
    return true;
  } else {
    return false;
  }
}

console.log(myFilter([1, 2, 3, 4, 5, 6], isEven)); // [2,4,6]
console.log(myFilter([1, 2, 3, 4, 5, 6], isGreaterThan5)); // [6]
```

Appraoch : Here we have followed these steps while creating the filter function

- First we made a function that will take an array and a callback function as arguments
- Then we make an empty array and returned it. This helps our data to be immutable
- Then we start looping through the array and checked it the return value from calling our callback function taking every item of the array as the arguments return true or false. If the result is true we pushed them into oor return array else we did nothing.
- This way we have made our own filter function.

### Map

Let us write our own mapping function similar to `Array.map()`

```jsx
function myMap(array, cb) {
  let returnArr = [];
  array.forEach((item) => {
    returnArr.push(cb(item));
  });
  return returnArr;
}

let myArray = [1, 2, 3, 4];

function doubleItem(item) {
  return item * 2;
}
console.log(myArray); // [1,2,3,4]
console.log(myMap(myArray, doubleItem)); // [2,4,6,8]
console.log(myArray); // [1,2,3,4]
```

Approach: We have followed the following steps while writing our own mapping function

- As we know map returns the same length array after doing some operation on the array and also doesn’t mutate the array.
- So the first step I have taken is to define our function which will take two arguments namely `array` and `callback function` .
- Then we declare an empty array and return the same array. This ensures immutability.
- Then we loop through every item of the array that will be passed as an argument and we keep pushing the return value of the callback function being called with the item to the return array.

### Reduce

Let us write our own mapping function similar to `Array.reduce()`

```jsx
function myReduce(array, cb, initialValue) {
  let accumulator = initialValue;
  array.forEach((item) => {
    accumulator = cb(accumulator, item);
  });
  return accumulator;
}

let myArray = [1, 2, 3, 4, 5];

let sum = myReduce(myArray, (acc, item) => acc + item, 0);
console.log(sum); // 15
let product = myReduce(myArray, (acc, item) => acc * item, 1);
console.log(product); // 120
```

Approach : We have followed the following steps while writing our own reduced function

- First, as we know reduce combine our array and reduce it on the basis of the reducer function being passed.
- The first step we took is defining our function which will take an array, a callback function, and an initial value.
- Then we made a local variable inside and assigned it to the value being passed as initialValue to the value of the accumulator.
- Then we loop over the array and keep assigning the accumulator to the value that came back as the return after calling the callback function with arguments as the accumulator and the item from the array.
- Finally, we return the accumulator

### Closure

Closure is one of the things which is very handy in functional programming. As we use higher order function it basically takes some input and returns output according to that. However, within the body of the function, we can also define another function and we can define it’s own value and variable inside it. And when we define inner function it has the access to the variable from the outer function. And when we return the inner function from the outer function an interesting thing happens which let us remember the value of the outer function if we call the inner function. This helps us to not pollute the global execution context. That’s a lot of words I think. Let’s learn the same through the code.

**Question:** Write a function which when called for the first three times returns “Hello World”and in the fourth call return “Call limit reached”.

**Approach 1:** Using a global variable

```jsx
let functionCallCount = 1;
function sayHelloTillThreeTimes() {
  if (functionCallCount <= 3) {
    functionCallCount += 1;
    return "Hello World";
  } else {
    return "Call Limit Reached";
  }
}

// calling the function
console.log(sayHelloTillThreeTimes()); // Hello World
console.log(sayHelloTillThreeTimes()); // Hello World
console.log(sayHelloTillThreeTimes()); // Hello World
console.log(sayHelloTillThreeTimes()); // Call Limit Reached
```

In the above, we have made the program work using the global variable which is not a good practice and we are polluting the global environment. So what we should do?

**Approach 2:** Not using the global variable

```jsx
// not using global variable
function sayHelloThreeTimes() {
  let functionCallCount = 0;
  return function inner() {
    functionCallCount += 1;
    if (functionCallCount <= 3) {
      return "Hello World";
    } else {
      return "Call Limit Reached";
    }
  };
}

let useSayHelloThreeTimes = sayHelloThreeTimes();

// calling the function
console.log(useSayHelloThreeTimes()); // Hello World
console.log(useSayHelloThreeTimes()); // Hello World
console.log(useSayHelloThreeTimes()); // Hello World
console.log(useSayHelloThreeTimes()); // Call Limit Reached
```

- In the above example, we make an outer function and then initialize a count variable name inside of it.
- Then we have returned a function from that outer function in which we are checking the count variable and returning the value according to it.
- Now when we use the function then we have the access to the count variable when we call our function elsewhere and we can say after 3rd call it started returning “Call Limit Reached”
- This is what we call closure in javascript because javascript is lexically scoped

### Partial Application and Currying

Partial application is the notion of remembering some arguments of a function helping us to make reuse easily.

Currying is basically making a multi-arguments function into a series of single-argument functions.

Let’s look at some code to get a more clear understanding

```jsx
// normal function
function greet(greetWord, name) {
  return `${greetWord} ${name}`;
}

let greetInEnglish = greet("Hello", "John");
let greetItalian = greet("Ciao", "John");

console.log(greetInEnglish); // Hello John
console.log(greetItalian); // Ciao John
```

In the code above we have made a very basic greet function that takes in the greeting word and the name and then returns a greeting message. However, it looks very reusable but what if we want to greet 100 people in English . Then if you will look you will see we have to pass “Hello” as the greetword every time and that’s not a very good thing I think so. So how can we do better?

Let’s look at another code example

```jsx
// currying
function greet(greetWord) {
  return function (name) {
    return `${greetWord} ${name}`;
  };
}

let greetInEnglish = greet("Hello");
// calling function
console.log(greetInEnglish("John")); // Hello John
console.log(greetInEnglish("Sarah")); // Hello Sarah

let greetItalian = greet("Ciao");
// calling the function
console.log(greetItalian("John")); // Ciao John
console.log(greetItalian("Sarah")); // Ciao Sarah
```

In the above example, we have made a curried greet function that takes in the greet word and returns us a function that further takes in the name and then returns the greet message.

Since our curried function used the idea of closure and hence when we define our function greetEnglish it will always remember the greeting word as “Hello” and now if we want to greet a hundred people in English we can simply pass their names only. This is the idea behind currying and partial application

### Function Composition

Since the idea behind functional programming is we have input coming and we have output and that output can be passed as input to other functions as well and this creates a kind of pipeline you can say.

When we write our program in a functional way we look at how the data will be flowing inside our program through different functions.

Here comes the idea of function composition where we take smaller functions and compose them together to get our desired output.

Pipelining: Where we will make a function that takes any number of single argument functions and should return a single function representing their composition.

```jsx
// // // ---- using recursion --- ///
// helpers
function length(arr) {
  return arr.length;
}

function head(arr) {
  return arr[0];
}

function tail(arr) {
  return arr.slice(1);
}

function pipeline(...functions) {
  if (length(functions) === 0) return (input) => input;
  if (length(functions) === 1) (input) => head(functions)(input);
  return function (input) {
    return pipeline(...tail(functions))(head(functions)(input));
  };
}

// helpers
function makeLoweCase(str) {
  return str.toLowerCase();
}

function slugify(str) {
  return str.split("").join("-");
}

let slugit = pipeline(makeLoweCase, slugify);

console.log(slugit("HelloWorld"));
```

In piping function together we need to keep in mind that the order matters

Now let's write a pipe using reduce

```jsx
function pipe(initialValue, ...functions) {
  return functions.reduce((acc, item) => {
    return item(acc);
  }, initialValue);
  return initialValue;
}

function makeLoweCase(str) {
  return str.toLowerCase();
}

function slugify(str) {
  return str.split("").join("-");
}

let slugit = pipe("Hello", makeLoweCase, slugify);

console.log(slugit);
```

### Immutability

Immutability which means not mutating is a concept that really goes hand in hand in functional programming.

How to keep avoid immutability while writing our javascript programs

- Don’t change in place instead replace
- Make a copy of our data and return that modified data instead of changing
- Use higher-order functions like map and filter to get free immutability
- One thing to also keep in mind is that copying data is not very efficient and if we have very big data then it can cause performance issues while copying it at different places.
- We can also use some libraries like ImmutableJs and Immer to ensure immutability while writing our javascript program.

### Functional Javascript Utility

1. Lodash/FP: It is not the usual lodash , it has been implemented it in a functional programming way keeping in mind immutability and purity. Still, we need to look at the documentation before using any code to make sure all things go right.
2. Ramda: It is one of the most popular ones and it is good for beginners

Thanks to this

[https://observablehq.com/collection/@anjana/functional-javascript-first-steps](https://observablehq.com/collection/@anjana/functional-javascript-first-steps)

[https://frontendmasters.com/courses/functional-js-fundamentals/](https://frontendmasters.com/courses/functional-js-fundamentals/)


Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data.

Introduction to Functional Programming


Searching happens so often and so quickly that we hardly get time to know what actually happens under the hood. When we type something on Google, an instant search takes place behind the scenes. It is really helpful to see a red underline when we write some words with wrong spelling in a word processing application. But have you wondered how the software instantly knows the same? That’s also an instant search behind the scenes. And besides all these, we have the ultimate achievement: the Web. The Web is so large that we can only guess its true size, and despite that web search engines can find relevant web pages in a fraction of seconds.

> How does the search engine find what we want so fast ?

# Understanding the Search Problem

To understand the search problem, at first, we need to know the terminologies and here it goes :

1.  Data collection: A collection of data.
2.  Record: Each item in data collection is called a record.
3.  Key: Every record is uniquely identified by a key.

For instance, when you use a dictionary the word you’re looking up is key, and the definition of that word is the record and the dictionary is obviously our data collection in this case.

The main objective of the search is to find the right record at a blazing fast speed because no one is gonna wait for minutes while searching for something on Google. So let’s dig deeper and learn how we achieve speed as well as accuracy while developing search engines.

**The search mechanism needs these many steps to achieve accuracy and speed:**

1.  Organization of Data (Sorting)
2.  Searching
3.  Indexing
4.  Hashing

Now, let's start to know each one in more detail.

## Organizing the data

Well-organized data is a must for efficient search. When you visit a bookstore and if the books are organized alphabetically by the author names. It’s easy to know where to look for, like our dictionary example. If the bookstore has no such organization of books then it will be harder for us to know where to look for. So to solve this problem we may start from one end and keep looking till the end of the shelves until we find that particular book. This process can also be called a sequential search and is not efficient. Therefore, it is really important to keep our data in an organized form which in computer science terms is known as sorting of data. There are numerous ways to sorting and each one of them is useful in some or other use case. The most commonly used sorting algorithm is quick sort and merge sort, while there are many other sorting methods like selection, insertion, bubble sort, etc. Comparing the selection sort and quick sort, on a particular computer a selection sort of 1,000,000 records would take around 3 hours, while a quick sort would take only about 11 minutes. That’s really amazing.

## A simple search method: Binary Search

When data is in order, the software can find a particular record easily. Binary search is a simple search method where we search some particular key by choosing between two alternatives. Each step in a binary search eliminates half of the records from consideration which means it scales very well. In a linear search doubling the size of data doubles the time needed for an average search while in a binary search doubling the data just adds one more step. A linear search on average will examine 500,000 records while searching in a data of 1,000,000 whereas a binary search will examine no more than 20 for the same data size.

## Indexing and Why it is necessary?

To keep things simple, our examples to this point have used just record keys but in practice, the rest of the records has to be stored somewhere else, and this can cause problems. To see why we have to dig deeper to understand the choice software faces when allocating storage space for data, whether in main memory, on a hard drive, or anywhere else.

**—Fixed-size storage allocation**: Fixed-size allocation assigns each record the same amount of space and it is commonly used for data that always has the same size or has a small maximum size. For example Credit Card number of 16 digits or allocation for a customer name of a maximum of 20 letters. So if the name is less than 20 the space is wasted but since the allocated space is small that doesn’t bother much.

**— Variable size storage allocation:** Variable size allocation exactly fits the data. For example a collection of MP3 files we allocate variable memory for that. The longer the song, the larger the MP3 file. This is because a short pop song would be of 3–4 MB while a rock song might be as large as 20MB. We will never want to allocate 20 MB for each song as a fixed allocation as it will waste a lot of memory. Hence we allocate variable storage for these.

Although from the above example we have seen variable allocation uses space efficiently, but for an efficient search method, fixed storage allocation is required. This is because storage locations are nothing but numerical _addresses._ Every byte in a digital storage — whether in computer’s main memory, hard disk, etc. can be precisely located by its _addresses._

> For a method like binary search it is essential to find the record quickly which can only be achieved when we have a fixed size records. Without fixed-size record , the only way to find a record in particular position is to count the records, which is just a linear search and it totally defeats the point of efficiency.

> Hence choosing between fixed memory allocation and variable memory allocation means choosing between **efficient search** and **efficient storage.**

To solve this problem a technique called indexing is used which gives us both, i.e., **an efficient search** as well as **efficient storage.** Indexing just separates the keys from the rest of the records, much as a library card catalog allows readers to search for books on cards before actually retrieving the books from the shelves. **_An index is nothing but a table of records keys and addresses._ **The address themselves are stored as binary with a fixed number of digits. The index of the data is stored in the main memory e.g. in Microsoft “32-bit” and “64-bit” it has 32 and 64 bit as the main memory and hence it helps you refer to the particular address to search efficiently using something like a binary search. The rest of the record data is stored in a variable size allocation. This eventually produces data that is efficient for storage as well as for searching. We can have multiple indexes for different search criteria, and because the main record is just referenced by an address, having multiple indexes doesn’t greatly affect the total storage. For example, we can have data collection of songs where we can create multiple indexes based on different parameters like an artist, name of song, singer, genre, etc. And this eventually offers efficient storage as well as efficient search too.

_In the next part, we’ll learn about_ **_hashing_ **_and how it works under the hood, we’ll also learn about_ **_Web Search_** _and how Google and other_ **_search engine rank_** _their result, how they use their index effectively and what possibilities are there in the future for the search problem._

**I hope you’ve learned something good from here for sure. Thanks for the read.**


Searching happens so often and so quickly that we hardly get time to know what actually happens under the hood. When we type something on Google, an instant search takes place behind the scenes.

The Journal

Debouncing and Throttling in JavaScript

Types and Coercion in JS

Introduction to Functional Programming

How Search System Works Part I