Forem: Rahul Jindal

Currying in JavaScript

Rahul Jindal — Mon, 30 Jan 2023 03:18:35 +0000

Currying is a functional programming technique that involves transforming a function with multiple arguments into a series of functions that each take a single argument.

In JavaScript, currying involves breaking down a function that takes multiple arguments into a series of functions, each of which takes a single argument. The first function returns another function that takes the next argument, and so on, until all arguments have been passed to the function. The final function then returns the result.

Here is an example of normal function in JavaScript:

function add(a, b) {
  return a + b;
}

Here is an example of a curried function in JavaScript:

function add(a) {
  return function(b) {
    return a + b;
  };
}

Prerequisite

Understanding closures is a pre-requisite to understanding currying in JavaScript. Currying leverages the closure property of functions in JavaScript to capture arguments and build up a complete set of arguments over time. By using closures, currying allows you to partially apply arguments to a function, and create new functions with a fixed set of arguments that can be called later with the remaining arguments. Without a solid understanding of closures, it can be difficult to understand how currying works and why it is useful.

Benefits of Currying

1 Reusable functions: Currying allows you to create reusable functions that can be partially applied with some arguments and then used multiple times with different arguments.

const add = (a) => (b) => a + b;

const add5 = add(5);
const add10 = add(10);

console.log(add5(3)); // 8
console.log(add10(3)); // 13

2 Readability: Currying can make code easier to read and understand by breaking down complex functions into smaller, more manageable functions.

const add = (a) => (b) => (c) => a + b + c;

const add5 = add(5);
const add5And10 = add5(10);

console.log(add5And10(3)); // 18

3 Composition: Currying allows you to compose functions together to create new functions, making it easier to write and manage code.

const add = (a) => (b) => a + b;
const multiply = (a) => (b) => a * b;

const add5 = add(5);
const double = multiply(2);

const doubleAndAdd5 = (x) => add5(double(x));

console.log(doubleAndAdd5(3)); // 11

The use of currying in this example makes the code more composable and maintainable by breaking down complex functions into smaller, simpler functions that can be composed together to create the final result.

4 Easier testing: Functions that are curried are easier to test, as you can test each individual function in isolation.

5 Better code organization: By breaking down functions into smaller, more manageable functions, currying can help to improve the organization of your code.

const add = (a) => (b) => a + b;
const multiply = (a) => (b) => a * b;

const add10 = add(10);
const multiplyBy5 = multiply(5);

const add10AndMultiplyBy5 = (n) => add10(multiplyBy5(n));

console.log(add10AndMultiplyBy5(2)); // 20

The use of currying in this example improves code organization by breaking down the simple add and multiply functions into smaller, more manageable functions that can be composed together in a single expression to achieve the desired result. This can help to make the code more readable, maintainable, and reusable.

6 Improved performance: Currying can lead to improved performance, as partially applied functions can be optimized and cached, reducing the number of function calls and improving performance.

const memoizedFetch = (() => {
  const cache = {};
  return (url) => {
    if (cache[url]) return Promise.resolve(cache[url]);
    return fetch(url)
      .then((response) => response.json())
      .then((data) => {
        cache[url] = data;
        return data;
      });
  };
})();

const fetchUsers = memoizedFetch("https://jsonplaceholder.typicode.com/users");
const fetchPosts = memoizedFetch("https://jsonplaceholder.typicode.com/posts");
const fetchTodos = memoizedFetch("https://jsonplaceholder.typicode.com/todos");

fetchUsers.then(console.log); // [{...}, {...}, ...]
fetchPosts.then(console.log); // [{...}, {...}, ...]
fetchTodos.then(console.log); // [{...}, {...}, ...]

The use of currying in this example improves performance by allowing us to cache the results of previous requests and avoid making the same request multiple times. This can be particularly useful when the request is time-consuming or has a high latency, as it allows us to cache the result and reuse it whenever possible.

7 Better function composition: When functions are curried, they can be composed in a more flexible way, making it easier to write complex functions and making the code more maintainable.

const multiply = (a) => (b) => a * b;
const add = (a) => (b) => a + b;
const modulo = (a) => (b) => b % a;

const isOdd = modulo(2);
const double = multiply(2);
const increment = add(1);

const processNumber = (num) =>
  double(increment(isOdd(num) ? num : increment(num)));

console.log(processNumber(2)); // 6
console.log(processNumber(3)); // 8

Applications of Currying

1 Event handling: Currying can be used to simplify event handling in a program by partially applying event handlers with specific arguments, making it easier to handle similar events in a generic way.

const handleClick = (elementId) => (event) => {
  console.log(`Clicked on element with id: ${elementId}`);
};

const button1 = document.getElementById('button1');
button1.addEventListener('click', handleClick('button1'));

const button2 = document.getElementById('button2');
button2.addEventListener('click', handleClick('button2'));

2 API calls: Currying can be used to abstract API calls and make them more flexible and reusable by partially applying them with specific parameters, reducing the need to repeat the same code for similar API calls.

3 Data processing: Currying can be used to simplify data processing pipelines by partially applying functions with specific parameters, making it easier to process data in a modular and composable way.

const curry = (fn) => {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...args2) {
        return curried.apply(this, [...args, ...args2]);
      };
    }
  };
};

const filterData = curry((fn, data) => data.filter(fn));
const filterNumbers = filterData((x) => typeof x === "number");
const result = filterNumbers([1, "hello", 3, "world", 5]); 

console.log(result); // [1, 3, 5]

Conclusion

In conclusion, currying is a concept from functional programming that involves transforming a function with multiple arguments into a sequence of functions, each taking a single argument. Currying can make it easier to reuse and compose functions, leading to more maintainable and readable code. While not directly useful in user interface development, it can be a helpful concept in functional programming that can lead to improved code quality. Whether or not to use currying in a project depends on the specific needs and constraints of that project, and its use should be evaluated based on the specific requirements.

Consistent Hashing

Rahul Jindal — Wed, 18 Jan 2023 12:42:06 +0000

Consistent hashing is a method of distributing requests among a dynamic set of servers which will allows for a more efficient use of resources and improved performance, as well as the ability to easily add or remove servers without disrupting the system. But, Before we discuss consistent hashing it is important to know what is hashing.

Hashing is a technique of converting data into a fixed-size output called a hash or a digest. An example of hashing is to use modulo in a distributed caching system with 4 servers ( s0, s1, s2, s3 ). The hash function will use IP ( 192.168.1.100 ) of the incoming request as the key and divide it with the total number of servers( 4 ), then remainder will be the server to which request should be redirected to.

hash(192.168.1.100) = (192.168.1.100 % 4) = 0

So, In the above example incoming request would be assigned to s0. Given below is an example how mapping to different servers will look like when multiple requests are being sent.

Modulo Operator Limitations as Hash Function

In practice, it is not recommended to use modulo operator as a simple hash function, as it can lead to poor distribution of keys and poor performance. Suppose In the above example, a server gets removed. Then keys distribution will be like this.

Here we need to remap all the request to the different servers which will lead the client to fetch data from the wrong servers and cause cache misses with uneven load distribution. Because of these issues consistent hashing came into play.

Consistent Hashing Working

A virtual circle, also known as a hash ring, is created, where each server is assigned a unique position on the ring.
A hash function, such as SHA-1 or MD5, is used to map each server and each data item ( can be IP or any kind of data like key in key-value pair systems) to a unique position on the virtual circle. Hash function also defines the hash space which refers to the range of values that the hash function can output. The hash space of SHA-1 is 2¹⁶⁰ which means there are 1.46 x 10⁴⁸ unique hash values that can be produced by the SHA-1 hash function.
When a request for a data item is received, the hash function is used to determine the position of the data item on the ring.
The request is then directed to the server whose position on the ring is closest to the position of the data item by moving in clockwise direction.
When a server is added or removed from the system, the positions of the other servers on the ring do not change, but the data items that were hashed to positions on the ring that are closest to the new or removed server, are re-hashed to the new closest server.
This way, only a small subset of data items need to be re-hashed when a server is added or removed, minimizing the disruption to the system.

Hash Space and Hash Ring Limitations

Hash space limitations: The size of the hash space, which is the range of values that the hash function can output, can be a limiting factor in consistent hashing. If the hash space is too small, it may not be able to accommodate all the servers or data items in the system, resulting in a high number of collisions. On the other hand, if the hash space is too large, it may not make efficient use of resources.
Hash ring limitations: The use of a hash ring can also have limitations. The number of positions on the hash ring is fixed, and if the number of servers or data items exceeds the number of positions, collisions will occur.
Scalability: Consistent hashing can become less efficient as the number of servers or data items increases, as the number of remappings required can become large.
Load balancing: Consistent hashing does not take into account the load on each server, so it may not distribute the load evenly among the servers.
Performance: Consistent hashing can have poor performance when the number of collisions increases.
Complexity: Consistent hashing can be computationally expensive and time-consuming when a server is added or removed from the system, as it requires remapping of data items or requests.
Limited fault tolerance: Consistent Hashing doesn't take into account the fault tolerance, if a node goes down it will lead to a redistribution of keys which can cause a temporary disruption in the system.

To overcome some of the limitations of hash ring and hash space limitation, virtual nodes are being introduced.

Virtual Nodes

In consistent hashing, virtual nodes are used to improve the distribution of data or requests among the servers. Each physical server in the system is assigned multiple virtual nodes or "tokens" and these tokens are used to determine the positions on the hash ring. This allows for a more even distribution of data or requests among the servers and can improve the performance of the system.

In the above diagram we can clearly see servers are distributed at different positions on the hash ring which provides more even data distribution and enhanced load balancing on each server. Each virtual node is being read as s0_0, s0_1, s0_2 where s0 is the server and 0,1,2 being the position of the virtual node on hash ring.

Benefits of Virtual Nodes

Hash space limitations: By using virtual nodes, the size of the hash space can be increased, reducing the number of collisions that occur. For example, if a physical server is assigned 4 virtual nodes ( s0_0, s0_1, s0_2, s0_3 ), it would have 4 times more positions on the hash ring keeping the hashed value constant than a physical server with 1 virtual node ( s0_0 ). This increases the number of possible positions on the hash ring, reducing the chance of collisions and improving the distribution of data or requests among the servers.
Hash ring limitations: The use of virtual nodes allows for a larger number of positions on the hash ring, increasing the number of servers or data items that can be accommodated.
Scalability: Virtual nodes can improve the scalability of consistent hashing, as it can accommodate a large number of servers or data items without a significant increase in the number of remappings required.
Load balancing: Virtual nodes can improve load balancing by distributing the load more evenly among the servers.
Performance: Using virtual nodes can improve the performance of consistent hashing, as it reduces the number of collisions and remappings required.
Complexity: Using virtual nodes can reduce the computational complexity of consistent hashing, as it reduces the number of remappings required when a server is added or removed.
Fault tolerance: Virtual nodes can increase the fault tolerance of the system, because if a node goes down, the load is distributed among the other virtual nodes and physical nodes.

Conclusion

In conclusion, consistent hashing is a method of distributing requests among a dynamic set of servers. It uses a hash function to map each server and data item to a unique position on a virtual circle, or "hash ring," and then uses the hash of the request to determine which server the request should be directed to. The key benefit of consistent hashing is that it allows for the addition or removal of servers with minimal remapping of requests to servers.

Consistent hashing is used in several distributed systems, such as distributed caching, distributed storage, and distributed databases, to distribute the load of data and requests among the available servers. This allows for a more efficient use of resources and improved performance, as well as the ability to easily add or remove servers without disrupting the system.

However, consistent hashing has some limitations, such as hash space limitations, hash ring limitations, scalability, load balancing, performance, and complexity. To overcome these limitations, virtual nodes, dynamic consistent hashing, rendezvous hashing, and Maglev hashing have been proposed as alternative methods.

Overall, consistent hashing is a useful technique for distributing data or requests among servers or resources in a dynamic and efficient manner, but it is important to consider the trade-offs involved and to choose the best method for the specific use case.

"this" keyword in JavaScript

Rahul Jindal — Wed, 18 Jan 2023 04:45:20 +0000

In JavaScript, this keyword stores the reference of the object. Unlike in many other languages this is not bounded to a class in JavaScript, it's value is being evaluated during the run-time.

this keyword take the reference of the object who is calling the method.

const consumer = { description: "Consumes Something" }
const producer = { description: "Produces Something" }

function printDescription() {
   console.log( this.description );
}

// Same printDescription function is being used in both the Objects
consumer.printDescription = printDescription;
producer.printDescription = printDescription;

consumer.printDescription(); // Output:- "Consumes Something"
producer.printDescription(); // Output:- "Produces Something"

In the above example, when consumer.printDescription() is called , this will store the reference of the object who is calling the method, which is consumer in this case and it will give the description provided in the consumer object. Similarly when producer.printDescription() is being called, this will refer to the producer object and console "Produces Something".

Using "this" keyword in function

this keyword can even be used inside a function without using an object

function printDescription() {
   console.log( this.description );
}

printDescription(); // Output:- undefined

In non-strict mode, value of this in such cases will be the global window object and properties existing on the window object can be accessible via this keyword.

window.description = "Description added in window object"

function printDescription() {
   console.log( this.description );
}

printDescription(); // Output:- "Description added in window object"

While in strict mode, this will be undefined and above example will give an error for trying to access description on undefined.

No "this" in Arrow function

Arrow function do not have their own this, If we use this inside the arrow function, then it is taken from the outer function.

const consumer = {
   description: "Consumes Something",
   printDescription: function () {
       const arrow = () => { console.log(this.description) }
       arrow();
   }
}

consumer.printDescription(); // Output:- "Consumes Something"

In the above example, consumer calls the printDescription method, because of which this inside the printDescription will have the reference of consumer object.

In printDescription method, when arrow function is being called, this will be taken from the outer function which currently has the reference of "consumer" object and it will result in the description value stored inside consumer object.

This special feature of arrow function helps in resolving the issue of losing reference of this keyword in case of nested function calls.

const consumer = {
   description: "Consumes Something",
   printDescription: function () {
       function fn() { console.log(this.description) }
       fn();
   }
}

consumer.printDescription(); // Output:- undefined

When printDescription is called, this will have the reference of consumer object, because consumer is calling the printDescription method, but inside the fn function in printDescription method, this will have the reference of global window object because no other object is calling the fn function which is similar to the case which we discussed above in Using "this" keyword in function section.

This will lead to losing the reference of consumer object in the nested function call, which can be resolved with the help of arrow function.

Alternative solution for losing "this" keyword in nested function calls

There is an alternative solution to keep the reference of main object inside the nested calls without the use of arrow functions.

const consumer = {
   description: "Consumes Something",
   printDescription: function () {
       const that = this;
       function fn() { console.log(that.description) }
       fn();
   }
}

consumer.printDescription() // Output:- "Consumes Something"

We can store the value of this keyword in some variable and use that variable inside the nested function call in place of this keyword.