DEV Community: C K Sanjay Babu

Bun is delicious. But why was it baked?

C K Sanjay Babu — Sat, 16 Sep 2023 10:39:07 +0000

Bun is a brand new javascript runtime designed to be a "drop-in replacement for Node.js". The 3 pillars of Bun according to their website are:

Blazing fast performance.
Elegant & optimized APIs
Cohesive DX

Check out their announcement for more details.

The first impressions are great. It has certainly piqued my curiosity and I am going to try it out for sure. But enough about it. This blog isn't to talk about how great Bun is. But to talk about why it was needed in the first place. Even though Bun is a promising new JavaScript runtime, node.js is still the more mature platform with a larger ecosystem. Like all things in life, node.js isn't perfect. So we have had many runtimes come up in recent years to address the cons of node.js. As a result, it is still important to understand the shortcomings of Node.js.

Let's discuss the major disadvantages of node.js. For each of them, let's see

What is it?
Why does it occur?
Where does it occur? with a real-life app example
Workaround in node.js

Blocking I/O Operations

What?

Node.js is designed for non-blocking, event-driven I/O operations. However, it can suffer from performance issues when dealing with a lot of synchronous or blocking I/O operations.

Why?

When a Node.js application performs blocking I/O operations, it can cause the event loop to stall, affecting the application's responsiveness and potentially leading to slower request processing.

Where?

Consider a file upload service that processes and stores large files. If Node.js blocks while reading or writing files, it can slow down the upload process for other users, resulting in a poor user experience.

Workaround

To mitigate blocking I/O issues, you can use asynchronous versions of I/O operations or delegate blocking tasks to worker threads. The effectiveness of these workarounds depends on the specific use case. Using asynchronous I/O operations is recommended for most cases, but for CPU-bound tasks, offloading them to worker threads may be necessary. Be mindful of the added complexity when choosing a workaround.

Single-threaded Nature

What?

Node.js is single-threaded, which means it operates on a single process. This can be a disadvantage when handling CPU-intensive tasks because it can lead to blocking the event loop.

Why?

In Node.js, when a CPU-intensive task is being processed, it can block the entire event loop, making your application less responsive to other incoming requests or tasks.

Where?

Imagine a real-time gaming server using Node.js. If a single thread is occupied with a CPU-intensive task, such as collision detection or physics calculations for one player, it could delay updates for all other players, causing lag and a poor gaming experience.

Workaround

One common workaround is to offload CPU-intensive tasks to worker threads or external processes. Node.js provides the worker_threads module for this purpose. While this can help mitigate the issue by allowing parallel processing of tasks, it adds complexity to your application. Whether to use this workaround depends on your specific use case. If CPU-bound tasks are rare and can be isolated, it may be worth using worker threads. However, if your application frequently faces CPU-bound tasks, you might consider using a different runtime or language more suited to parallel processing.

Limited Multi-core Scalability

What?

Node.js's single-threaded nature limits its ability to fully utilize multi-core CPUs, which can be a bottleneck for applications that require high levels of concurrency.

Why?

Since Node.js primarily runs on a single thread, it can't take full advantage of multi-core CPUs by default. This means that, for CPU-bound tasks, Node.js won't be as efficient as other runtime environments designed for multithreading.

Where?

In applications like video streaming services or data processing pipelines, where handling multiple concurrent requests or tasks is crucial, Node.js may not scale as well as alternatives like Python with multi-threading or Go with goroutines.

Workaround

To address limited multi-core scalability, one approach is to use clustering. Node.js provides a built-in module cluster that allows you to create multiple child processes, each running on a separate core. This can distribute the workload across cores, but it adds complexity and requires careful management. Alternatively, for CPU-bound tasks, consider using a different runtime or language designed for multi-threading or multi-processing, depending on your application's needs.

Memory Consumption

What?

Node.js applications can consume a significant amount of memory, especially when handling many concurrent connections or large data sets.

Why?

Node.js uses a V8 JavaScript engine, which loads and compiles JavaScript code into memory. When dealing with a large number of requests, each requiring memory allocation, it can lead to high memory usage.

Where?

Consider a social media platform with millions of users. Handling simultaneous connections, user data, and media files can lead to substantial memory consumption, impacting server performance and requiring more resources.

Workaround

To manage memory consumption in Node.js, you can implement strategies like connection pooling, optimizing your code for memory efficiency, and scaling horizontally by adding more server instances. Additionally, monitoring tools can help identify memory leaks and bottlenecks. Choosing the appropriate instance size or containerization strategy based on your memory requirements is crucial.

Callback-based Code

What?

Callback hell, also known as callback pyramids, can make Node.js code harder to read and maintain due to its reliance on callbacks.

Why?

Node.js's asynchronous nature often leads to deeply nested callbacks, which can become challenging to manage as code complexity increases.

Where?

In a real-time chat application, handling multiple concurrent users and messages can result in complex, nested callback structures, making the codebase difficult to understand.

Workaround

To address callback-based code, it's advisable to use Promises or async/await, which provide more structured and readable ways to handle asynchronous operations. These constructs are highly effective and should be used to improve code quality and maintainability. However, it may take some effort to refactor existing callback-based code.

Ryan Dahl, the creator of node.js has also released Deno recently marketed as next-gen Javascript runtime which addresses the problems of node.js. It will be interesting to learn how the Bun team has handled these shortcomings and compare how it stacks up against both Deno & node.js. But that's a topic for another day. Adios!

The one with my blogging journey

C K Sanjay Babu — Wed, 11 May 2022 18:21:58 +0000

Chapter 1 - The one where a random guy faraway eating bat soup affected me!

I am a full-stack developer with 3 years of experience. I have always wanted to share my thoughts and contribute to the tech community which has helped me throughout my journey, but I always had some reason to back out. I even bought this domain (sanjaybabu.dev) back in 2020. But as we are all aware something massive happened in 2020 which disrupted the entire world like never before. I was fortunate enough to survive the pandemic with relatively minimal effects, but it still made enough alterations in my life to suspend this.

Chapter 2 - The one where I tried to eat a burger with a spoon!

In 2021, when life started to return to a semblance of normalcy, I started writing, but chose the wrong platform for doing it - Twitter and stopped writing within a week.

Why do I feel uncomfortable writing tech articles on Twitter?

Very short character limit. It's not nearly enough to explain any tech topics. No offense to tons of threads out there with some really high-quality content. But personally, I didn't like reading threads and hated writing them even more.
Inserting images for code snippets. It was cumbersome for me, the writer, and a worse experience for the reader since they cannot copy the code from the image.

But to be fair, these are not twitter's shortcomings. Twitter was not made for this. It was like trying to eat a burger with a spoon. It is possible, but it's just not the right way!

Chapter 3 - The one where I tried to fly without even standing up first!

A few weeks after giving up on being a Twitter blogger, I was working with react for a side project of mine and found that I was not comfortable with a lot of javascript. So I decided to brush up on my javascript and learn the advanced concepts!

That's when I thought "Why not write a blog about what I am learning?" Looked like a brilliant idea then. I could learn as well as write about it. It was like killing 2 birds with a single stone! Well to be fair, I did kill 2 birds with a single stone. Just not the way I expected. I stopped both learning and blogging. I tried to write a really impressive in-depth blog about each topic in JS like JS Engine, Hoisting, Closures, etc. Being in a slightly demanding full-time job, I got overwhelmed by learning and then documenting it and ended up doing nothing. It was like trying to fly before even learning to stand up first!

Chapter 4 - The one where I got on the right path

Now, I was sure about a few things this time due to my past learning experiences(failures!)

Platform - Publish in the personal blog(Powered by Hashnode) and cross-post it in Dev Community. No more Twitter shenanigans. Just tweet the link to the blog if possible.
Content - Should be short. Even if it's a small topic, some simple, useful byte-sized information.

So moving on, One day I was having a casual chat with my friend and he was sharing his recent interview experience and that's when I thought about the next idea for writing again. Writing daily about one atomic concept in java, javascript, or React which may be asked in an interview. It was a perfect fit for me and within 2 days of thinking of this idea, I published my first ever blog post(excluding Twitter) on my personal blog(blog.sanjaybabu.dev) and in DEV.to!

I started a series called 100 days of Interview Questions. This was a far far greater success than all of my previous experiments. I have so far published daily for 10 consecutive days in this series! I know this is a small sample size, but still, writing had many unexpected positive knock-on effects too.

I started waking up early and my eternally broken sleep cycle was finally fixed.
I got into "The flow state" which helped me at work too. I was now more focused than ever.
I got a few good ideas for side projects.
When updating my bio in dev.to & Hashnode, it asked me for other social media profiles. So I revamped my LinkedIn profile, Twitter profile, and Github profile which I was planning for a long time.

This was perfect. Almost! But..., yes! Of course, there is still a 'but'. After about 7 or 8 days, I began to realize the mistake in this chapter too! Can you guess what it is?

"The 100 days" part!

I learned another hard lesson that we should not put any pressure like X days, especially when you are just starting out. Now I am excited to work on the above-said side project ideas. I was trying to participate in ongoing writing contests in both dev.to & hashnode. But first I had to write this series because I committed to 100 days. So I have decided 100 days part is not gonna be 100 consecutive days, just 100 posts and taking some breaks in between. Which would have been so simple if I had not mentioned the X days.

The 100 days of Interview Questions series may not be a great success. But just few weeks ago, I couldn't even imagine a post like this without any preset content and writing from my heart instead! So it did get me on the right path and I will always be grateful for that!

Closing thoughts

Last but not the least, the dev.to community. The response(or lack of any) in hashnode was abysmal. Maybe it had something to do with publishing under a custom domain instead of hashnode.

However, dev.to community literally carried me and made sure I don't stop. Even a few likes or a couple of bookmarks or comments go a long way in motivating the new writers. The thought that even 1 fellow developer found my writing good enough to interact with it really makes my day!

So if anyone is reading this piece, go ahead and share your blogging journey in the comments! I always love to hear the origin stories!

Day 10 - How is abstraction achieved in java?

C K Sanjay Babu — Tue, 10 May 2022 17:59:40 +0000

Abstraction allows us to hide our implementation. It is one of the key properties of Object-Oriented Programming (OOP). In java, it is implemented using abstract class & Interface.

Abstract class

We can simply create an abstract class by including the abstract keyword in front of it. An abstract class cannot be instantiated. So no objects of an abstract class or constructors are allowed.


abstract class Animal {
    int type;
    abstract void move();
}

Interface

The interface is a blueprint of a class that is used to specify its behavior. Again an interface cannot be instantiated. It can have only abstract functions. It cannot have any function body. So we don't need to specify the abstract keyword.


interface Shape{
    String color;
    void draw();
}

When to use Abstract Class?

If we have a use case where "A is a B" consider using an abstract class.

Eg- Lion is an Animal , Neem is a Tree

When to use interface?

If we have a use case where "A can do some activity of B" consider using an abstract class.

Eg- Scream can give the sound of an Animal , Blossom can give a flower of a Tree

Day 9 - What is ref in react?

C K Sanjay Babu — Mon, 09 May 2022 12:45:21 +0000

In react, Refs provide a way to access or reference the DOM element from within a parent component. Generally, in react, we would use props for any interactions between the components. We can re-render the component with updated props to modify it. Refs provide a way to imperatively do this change.

When to use Refs?

According to react documentation,

Manage focus, text selection, or media playback.
Perform imperative animations.
Integrate with third-party DOM libraries.

When not to use Refs?

We use a library like react for its declarative programming style. We just specify this or that needs to be done and the react handles it. But when the ref provides us the flexibility of imperative control. Hence these should not be overused.

Example

class CustomTextInput extends React.Component {
  constructor(props) {
    super(props);
    // create a ref to store the textInput DOM element
    this.textInput = React.createRef();
    this.focusTextInput = this.focusTextInput.bind(this);
  }

  focusTextInput() {
    // Explicitly focus the text input using the raw DOM API
    // Note: we're accessing "current" to get the DOM node
    this.textInput.current.focus();
  }

  render() {
    // tell React that we want to associate the <input> ref
    // with the `textInput` that we created in the constructor
    return (
      <div>
        <input
          type="text"
          ref={this.textInput} />
        <input
          type="button"
          value="Focus the text input"
          onClick={this.focusTextInput}
        />
      </div>
    );
  }
}

Day 8- Undefined, Not defined & null in javascript

C K Sanjay Babu — Sun, 08 May 2022 13:16:47 +0000

Javascript handles values that don't or shouldn't exist by the use of undefined, not defined & null keywords. These may seem similar, but there are subtle differences between them.

Undefined

In JS, undefined is assigned to any variable that has been declared but not yet assigned.

There are many reasons why we get undefined. A few of them are :

Hoisting

All variables declared with var are hoisted in js. So we are able to access them even before declaration but they will return undefined.

Check here for more details about hoisting

When a variable is declared but accessed before its initialized

var count;
console.log(count); //undefined

When a method without a return value is assigned.

function print(a){
   console.log(a);
}
var str=print("Hello");
console.log("Value of str: "+str);

/*
Output:
Hello
Value of str: undefined
*/

Not defined

not defined error is thrown when a variable is not declared at all.

console.log(a);
console.log(b);
var a=10;
let b=100;

/*
Output:
undefined
Uncaught ReferenceError: b is not defined
 */

Note: Again for variable a we got undefined and not an error because of hoisting.

null

null is an object that can we used to explicitly an empty value.

The difference between null & undefined is that null is an object whereas type of undefined is itself undefined.

Day 7- Is Java pass by value or reference?

C K Sanjay Babu — Sat, 07 May 2022 16:55:26 +0000

Again Java passes variables in functions similar to js. Check out the detailed explanations here.

Day-6 - Is javascript pass by value or pass by reference?

C K Sanjay Babu ・ May 6 ・ 1 min read

#javascript #beginners #programming

Pass by Value

All primitive data types are passed by value in java.

class passByValue {
    public static void main(String args[]) {
        Integer i=0;
        increment(i);
        System.out.println("Value of i outside the function: "+i);
    }
    static void increment(Integer i){
        i++;
        System.out.println("Value of i inside the function: "+i); 
    }
}

/*
Output : 
Value of i inside the function: 1
Value of i outside the function: 0
*/

Pass by Reference

Objects & arrays are pass by reference in java

class PassByValue {
  public static void main(String[] args) {
    Integer[] array = new Integer[2];
    array[0]=2;
    array[1]=3;
    add(array);
    System.out.println("Result from main: " +(array[0]+ array[1]));
  }

  private static void add(Integer[] array){
    array[0] = 10;
    System.out.println("Result from method: " +(array[0]+ array[1]));
  }
}

/*
Output:
Result from method: 13
Result from main: 13

*/

Day-6 - Is javascript pass by value or pass by reference?

C K Sanjay Babu — Fri, 06 May 2022 17:20:49 +0000

It's both! Let's find out how.

Pass by value

Whenever a function is called, if the value of the variable is passed directly as the parameter, then the changes made to that parameter are not propagated beyond the function.

All primitive data types in javascript are passed by value.

Example

var a=10;
console.log("Value of 'a' before method called: "+a);
add(a);
function add(a){
   a++;
   console.log("Value of 'a' inside the method call: "+a);
}

console.log("Value of 'a' outside the method called: "+a);

/*
Output:
Value of 'a' before method called: 10
Value of 'a' inside the method call: 11
Value of 'a' outside the method called: 10
 */

Pass by Reference

Whenever a function is called, if the address of the variable is passed as a parameter directly instead of making a copy of it and just sending the value alone, then it's pass by reference. As we are still referencing the address inside the function, any change made to the variable inside the function will be propagated throughout the program.

Objects and Arrays are passed by reference in javascript

Example

var user={
   id:1,
   firstName:"John",
   lastName:"Doe"
}

console.log("Value of 'user' before method called: "+user.firstName+" "+user.lastName);

print(user);

function print(user){
   user.lastName="Wick";
   console.log("Value of 'user' inside the method call: "+user.firstName+" "+user.lastName);
}

console.log("Value of 'user' outside the method call: "+user.firstName+" "+user.lastName);

/*
Output:
Value of 'user' before method called: John Doe
Value of 'user' inside the method call: John Wick
Value of 'user' outside the method call: John Wick
*/

Day 5 - Why is java not a Pure Object-Oriented language?

C K Sanjay Babu — Thu, 05 May 2022 03:02:17 +0000

For any programming language to be called a pure object-oriented language, it should satisfy all the 7 rules below :

Encapsulation/Data Hiding
Inheritance
Polymorphism
Abstraction
All predefined types are objects
All user-defined types are objects
All operations performed on objects must be only through methods exposed to the objects.

Java fails the rule no-5 and 7.

Why java fails the "All predefined types are objects" rule?

We have primitive data types - boolean, byte, char, int, float, double, long, short which are predefined types but not objects.

Why java fails the "All operations performed on objects must be only through methods exposed at the objects" rule?

It's due to the static keyword. When a variable is declared as static, they become class-level elements instead of instance variables. These static variables are accessible directly with the class name and can be used without the objects.

Day 4 -Difference between slice() and splice() in javascript!

C K Sanjay Babu — Wed, 04 May 2022 10:33:40 +0000

slice() and splice() are both methods on javascript arrays!

slice()

slice() copies the items from the original array and returns the elements the selected elements. The original array remains unaffected when using slice().

The Syntax

slice(start,end)

Params

start - specifies the index to start the slicing. The indexing starts from 0. If negative value n is specified, then the last n values will be retrieved.
end - specified the index till which elements are to be selected. Not inclusive. If negative value n is specified, then the last n values will be excluded.

Examples

let a=[0,1,2,3,4,5,6,7,8,9];

//Return the elements from 3rd index till 6th index
console.log(a.slice(3,6)); //returns [3, 4, 5]

//Return all the elements from 2nd index
console.log(a.slice(2)); // returns [2, 3, 4, 5, 6, 7, 8, 9]

//Return the last 3 elements
console.log(a.slice(-3)); // returns [7, 8, 9]

//Return all the elements from 1st index except the last 3 elements
console.log(a.slice(1,-3));// returns [1, 2, 3, 4, 5, 6]

splice()

splice() removes the items from the original array and then returns the selected elements. The contents of the original array are also affected when using splice().

The Syntax

splice(start,delete-count, item1, item 2, .... n)

Params

start - specifies the index to start the splicing. The indexing starts from 0. If negative value n is specified, then the last n values will be retrieved.
delete-count - It's the no. of items that need to be deleted from the original array and returned.
item1, item 2, .... n - It's the new items to be added starting from the start index.

Examples

let a=[0,1,2,3,4,5,6,7,8,9];

//Delete the elements from 3rd index till 6th index
console.log(a.splice(3,3)); //returns [3, 4, 5] and a=[0, 1, 2, 6, 7, 8, 9]

//Delete 4 elements from 2nd index
let a=[0,1,2,3,4,5,6,7,8,9];
console.log(a.splice(2,4)); //returns [2, 3, 4, 5] and a=[0, 1, 6, 7, 8, 9]

//Delete all the elements from 2nd index
let a=[0,1,2,3,4,5,6,7,8,9];
console.log(a.splice(2)); // returns [2, 3, 4, 5, 6, 7, 8, 9] and a=[0, 1]

//Delete the last 3 elements
let a=[0,1,2,3,4,5,6,7,8,9];
console.log(a.splice(-3)); // returns [7, 8, 9] and a=[0, 1, 2, 3, 4, 5, 6]

//Delete 2 elements from the 5th index and add 2 new elements
let a=[0,1,2,3,4,5,6,7,8,9];
console.log(a.splice(5,2,"five","six")); // returns [5, 6] and a=[0, 1, 2, 3, 4, 'five', 'six', 7, 8, 9]

//No deletion. Just add 2 new elements before the 6th index
let a=[0,1,2,3,4,5,6,7,8,9];
console.log(a.splice(6,0,5.1,5.2)); // returns [] and a=[0, 1, 2, 3, 4, 5, 5.1, 5.2, 6, 7, 8, 9]

Day 3 - What are fragments in React?

C K Sanjay Babu — Tue, 03 May 2022 04:15:22 +0000

As you may already know, A React component can return only 1 node. So if we had multiple elements to return, then we have to simply wrap a <div> around them and return a single element like below.

render() {
  return (
    <div>
      <LeftItem />
      <RightItem />
    </div>
  );
}

This affected the sematic nature of HTML and resulted in react apps having lots of unwanted nested components. So in order to solve this, Fragments was introduced in react v16.2. Fragments are syntax that allows a React component to return multiple elements without wrapping them in an extra DOM node.

Now we instead of adding <div> like before, we can use <React.Fragment>

render() {
  return (
    <React.Fragment>
      <LeftItem />
      <RightItem />
    <React.Fragment>
  );
}

Note that there is also a shorthand way to create Fragments. We can simple use empty tags <> & </> instead of <React.Fragment>

Day 2 - Differences between checked & unchecked exceptions in java!

C K Sanjay Babu — Mon, 02 May 2022 03:19:46 +0000

Checked Exceptions

These are checked during compile time itself. Checked Exceptions should be either handled or the same should be notified with the throws keyword.

Example - SQLException, IOException.

Unchecked Exceptions

These exceptions are checked during runtime. The classes that inherit the RuntimeException fall under unchecked exceptions. It's not necessary to handle these exceptions.

Example - NullPointerException, ArrayIndexOutOfBoundsException.

Day 1 - What is hoisting and how to prevent it in javascript?

C K Sanjay Babu — Sun, 01 May 2022 09:47:41 +0000

What is hoisting?

The default behavior of the javascript interpreter is to move variable and function declarations to the top. This behavior is called Hoisting.

Take a look at the below code snippet!

console.log(x);
console.log(announce());
var x = 100;
function announce() {
  console.log('Hello World');
}

// Output :
// undefined
// Hello World

Note that, we are calling the variable 'x' and function 'announce' even before we are declaring it. In most languages, this would result in an error!
But it works in javascript due to hoisting!
Now coming to the output itself, we see that the value of the variable is not printed but the function is executed properly. This is because, for variables, only the declarations are hoisted not the initialization. So we don't get an error while calling the variable before its declaration statement. But at the same time, we won't get the initialized value either.

As you can see, clearly hoisting makes our code unpredictable because, even if a variable is assigned a value only once, its value is not the same throughout. Hence many developers don't prefer hoisting.

How to prevent hoisting?

Javascript interpreter will hoist lines starting with


  and

 ```function```


We can prevent hoisting by using

 ```let```

 or

 ```const```

 keywords instead like below.

let x = 100;
let announce=function() {
console.log('Hello World');
}



 Hoisting will not take place for the above code since they don't start with

 ```var```

  or

 ```function```

. So if we try to access the variable 'x' or the function 'announce' before the declaration, we will get a

 ```not defined```

 error.