DEV Community: Sonu kumar

How to Install Cursor AI Editor on Linux, Ubuntu (2025 Update)

Sonu kumar — Thu, 06 Feb 2025 08:48:05 +0000

Cursor is a smart code editor designed for pair programming with AI. You can download it on Windows, Mac, and Linux. While it's easy to install on Mac, I found it a bit tricky on Ubuntu Linux. After some research, I figured it out! Here's a simple guide to help you install Cursor on Ubuntu Linux.

The cursor lets you write code using instructions.
Update entire classes or functions with a simple prompt, Intelligent, fast, and familiar, Cursor is the best way to code with AI.

Step-by-Step Installation Guide

Step 1:

Go to the Cursor website and click on the "Download" button.

Step 2:

Once downloaded, you'll find a file ending with .AppImage in your Downloads folder.

What's an AppImage? It's a universal software package for Linux that doesn't need traditional installation.

Step 3:

Before running the file, make it executable. Open your terminal, navigate to your Downloads folder, and run:

chmod +x cursor-0.45.8-build-250201b44xw1x2k-x86_64.AppImage

Note: Replace cursor-0.45.8-build-250201b44xw1x2k-x86_64.AppImage with your file's name.

Step 4:

If you see an error about libfuse.so.2, don't worry! This means you need FUSE to run the AppImage.

Step 5: Install FUSE by running:

sudo apt-get install libfuse2

Step 6:

Now, make the file executable again:

chmod +x cursor-0.45.8-build-250201b44xw1x2k-x86_64.AppImage

Step 7: Run the AppImage file:

./cursor-0.45.8-build-250201b44xw1x2k-x86_64.AppImage

Adding Cursor to Your Applications List

To easily access Cursor, add it to your applications list:

Move the AppImage to the /opt folder:

sudo mv cursor-0.45.8-build-250201b44xw1x2k-x86_64.AppImage /opt/cursor.appimage

After move your cursor file in /opt dir you can see:

cd /opt
ls

You can also run from here with the same command like above we have run but this is not required because we have created the runnable from application but for knowledge and info I will share the details:

./cursor.appimage

Create a desktop entry:

sudo nano /usr/share/applications/cursor.desktop

Paste the following into the file:

[Desktop Entry]
Name=Cursor
Exec=/opt/cursor.appimage
Icon=/opt/cursor.png
Type=Application
Categories=Development;

Save the file by pressing Ctrl + X, then press Y, and Enter.

Final Step:

Add an icon for Cursor. Place a cursor.png image in the /opt directory.

If the icon doesn't appear, try logging out and back in.

That's it! Thanks for reading, and enjoy using Cursor! 😊

Understanding Bubble Sort Algorithm: A Step-by-Step Guide

Sonu kumar — Mon, 23 Dec 2024 05:11:00 +0000

Image Source: medium

Sorting is one of the most important parts of Data Structures and Algorithms. There are many types of sorting algorithms, and here is one of the easiest algorithms: Bubble sort.

Sorting algorithms are fundamental in computer science, and Bubble Sort is one of the simplest and most intuitive sorting algorithms. This post will explore how Bubble Sort works, analyze its time complexity, and walk through a JavaScript implementation.

In this series, I will share the complete Sorting Algorithm Data Structure and Algorithms using Javascript and start with Bubble Sort. If you like and want me to share the complete Sorting algorithm with an example, please like and follow me. It motivates me to create and prepare the content for you guys.

What is Bubble Sort?

Bubble Sort is an easy sorting algorithm that repeatedly steps through the list, compares adjacent elements (next elements), and swaps them if they are in the wrong order. This process is repeated until the list is sorted. The algorithm gets its name because smaller elements “bubble” to the top of the list.

JavaScript Implementation:

Let’s dive into the code to see how Bubble Sort is implemented in JavaScript:

// By default ascending order
function bubble_sort(array) {
    const len = array.length; // get the length of an array
    //The outer loop controls the inner loop, which means the outer loop will decide how many times the inner loop will be run.
    //If the length is n then the outer loop runs n-1 times.
    for (let i = 0; i < len - 1; i++) { 
        // Inner loop will run based on the outer loop and compare the value, 
        //If the first value is higher than the next value then swap it, loop must go on for each lowest value 
        for (let j = 0; j > len - i -1; j++) {
            // checking if the first element greater than to the next element
            if (array[j] > array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }

    return array; // return the sorted array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort(array));

// output data after sorted!
// [3, 7, 9, 11, 12];

Output

Sorting with Descding Orders:

// Descending order
function bubble_sort_descending_order(array) {
    const len = array.length;
    for (let i = 0; i < len - 1; i++) {
        for (let j = 0; j < len - i -1; j++) {
            // checking if first element greter than next element,
            if (array[j] < array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }

    return array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort_descending_order(array));

// output data after sorted!
// [ 12, 11, 9, 7, 3 ]

Output:

Already added comments and explained each line of the code above. but I will also explain in detail so it helps you to understand the complete process and codes.

How it works:

Initialization: We start by determining the length of the array, which helps control the number of iterations.
Outer Loop: This loop runs n-1 times, where n is the length of the array. Each iteration ensures that the next largest element is placed in its correct position.
Inner Loop: For each pass of the outer loop, the inner loop compares adjacent elements and swaps them if they are out of order. The range of the inner loop decreases with each pass because the largest elements are already sorted at the end of the array.
Swapping: If an element is greater than the next one, they are swapped using a temporary variable.
Return: Finally, the sorted array is returned.

Optimized Version:

// optimized version:
function bubble_sort(array) {
    const len = array.length; // get the length of the array
    //The outer loop controls the inner loop, which means the outer loop will decide how many times the inner loop will be run.
    //If the length is n then the outer loop run n-1 times.
    for (let i = 0; i < len - 1; i++) { 
        // Inner loop will run based on the outer loop and compare the value, 
        //If the first value is higher than the next value then swap it, loop must go on for each lowest value
        let isSwapped = false;
        for (let j = 0; j < len - i -1; j++) {
            //check if the first element is greater than the next element
            if (array[j] > array[j + 1]) {
                // then, swap the value array[j] to array[j+1]
                let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                isSwapped =  true;
            }
        }

        //If no element swap by inner loop then break;
        if (isSwapped === false) {
            break;
        }
    }

    return array;
}

const array =  [7, 12, 9, 11, 3]; // input data
console.log(bubble_sort(array));

// output data after sorted!
// [3, 7, 9, 11, 12];

Explanations:

for (let i = 0; i < len — 1; i++) This is the outer loop, which runs n-1 times, where n is the length of the array. The outer loop controls how many times the inner loop will execute. Each iteration of the outer loop ensures that the next largest element is placed in its correct position.
let isSwapped = false A boolean variable isSwapped is initialized to false. This variable is used to track whether any elements were swapped during the current pass of the inner loop. If no swaps occur, the array is already sorted, and the algorithm can terminate early.
for (let j = 0; j < len — i — 1; j++) { This is the inner loop, which iterates over the array elements up to len - i - 1. The - i part ensures that the loop does not consider the elements that have already been sorted in previous passes.
if (array[j] > array[j + 1]) { This condition checks if the current element is greater than the next element. If true, a swap is necessary to order the elements correctly.

let temp = array[j];
                array[j] = array[j + 1];
                array[j + 1] = temp;
                isSwapped = true;

These lines perform the swap of elements array[j] and array[j + 1] using a temporary variable temp. After the swap, isSwapped is set to true, indicating that a swap has occurred.

if (isSwapped === false) {
            break;
        }

After the inner loop completes, this condition checks if isSwapped is still false. If no swaps were made, the array is already sorted, and the outer loop can be exited early using break.
Finally, the sorted array is returned.

Time Complexity

The time complexity of Bubble Sort is (O(n²)) in the worst and average cases, where (n) is the number of elements in the array. This is because each element is compared with every other element. In the best case, when the array is already sorted, the time complexity can be (O(n)) if an optimization is added to stop the algorithm when no swaps are needed.

In the best-case scenario, when the array is already sorted, the algorithm can terminate early due to the isSwapped optimization, resulting in a time complexity of (O(n)).

Overall, bubble sorting is not efficient for large datasets due to its quadratic time complexity, but it can be useful for small arrays or as an educational tool to understand sorting algorithms.

Conclusion

Bubble Sort is an excellent algorithm for educational purposes due to its simplicity. However, it is not suitable for large datasets because of its quadratic time complexity. Despite its inefficiency, understanding Bubble Sort provides a foundation for learning more advanced sorting algorithms.

[Boost]

Sonu kumar — Sat, 21 Dec 2024 10:46:55 +0000

12 New JavaScript Features Every Developer Should Know

Sonu kumar ・ Dec 21 '24

#javascript #programming #learning #node

12 New JavaScript Features Every Developer Should Know

Sonu kumar — Sat, 21 Dec 2024 10:45:00 +0000

JavaScript is always evolving, and with each new version, it introduces features that make our lives as developers a little easier. Some of these features are game-changers, improving how we write and manage our code. If you’re a daily coder, it’s important to stay updated with these new features. In this post, I’ll walk you through some of the latest JavaScript features that are super useful and should be in your toolkit.

1. Optional Chaining (?.)

One of the most useful features added in recent versions of JavaScript is optional chaining. This allows us to safely access deeply nested properties in objects without worrying about whether an intermediate property is null or undefined.

Example:

Imagine you have a user object that may or may not have a profile:

code const user = { profile: { name: "John" } };
console.log(user.profile?.name);  // John
console.log(user.profile?.age);   // undefined

Without optional chaining, you would have to manually check each property, which can make the code messy. This small operator helps us avoid those checks, making the code cleaner and easier to read.

2. Nullish Coalescing Operator (??)

The nullish coalescing operator (??) is another neat feature introduced to help handle null or undefined values without affecting other falsy values like 0 or false.

Example


let userName = '';
let defaultName = 'Guest';

console.log(userName ?? defaultName);  // 'Guest' because userName is an empty string

Unlike the logical OR (||), which treats an empty string ("") or 0 as falsy values, ?? will only return the right-hand operand if the left is null or undefined.

3. Promise.allSettled()

If you’re working with promises in JavaScript, you’ve probably used Promise.all(). But did you know there's a more powerful version called Promise.allSettled()? This method waits for all promises to settle, regardless of whether they were fulfilled or rejected. It’s super handy when you need to know the result of all promises, even if some fail.

Example:


const p1 = Promise.resolve(3);
const p2 = Promise.reject('Error');
const p3 = Promise.resolve(5);

Promise.allSettled([p1, p2, p3])
  .then(results => {
    console.log(results);
  });
Output:

[
  { status: "fulfilled", value: 3 },
  { status: "rejected", reason: "Error" },
  { status: "fulfilled", value: 5 }
]

This is a great way to handle multiple async operations when you don’t want one failure to break the entire process.

4. BigInt for Large Numbers

We’ve all faced that problem of exceeding the limits of JavaScript’s Number type. JavaScript numbers are limited to values between -(2^53 - 1) and (2^53 - 1). If you need to work with numbers larger than that, BigInt is your friend.

Example:


const largeNumber = BigInt(1234567890123456789012345678901234567890);
console.log(largeNumber);

This will give you the ability to work with arbitrarily large integers without worrying about precision errors.

5. String.prototype.replaceAll()

If you’ve ever tried to replace all occurrences of a substring in a string, you probably used a regular expression with the replace() method. With replaceAll(), it’s much simpler. This method replaces all occurrences of a substring, and you don’t have to worry about global regex flags.

Example:


let message = 'Hello World, Welcome to the World!';
let updatedMessage = message.replaceAll('World', 'Universe');
console.log(updatedMessage);  // Hello Universe, Welcome to the Universe!

It’s simple, cleaner, and gets rid of the need for regular expressions.

6. Logical Assignment Operators (&&=, ||=, ??=)

These new operators provide a shortcut to combine logical operators with assignments. They’re a great way to write more concise code.

&&=: Assigns the value only if the left-hand value is truthy.
||=: Assigns the value only if the left-hand value is falsy.
??=: Assigns the value only if the left-hand value is null or undefined.

Example:


let count = 0;
count ||= 10;  // count is now 10, because it was falsy
console.log(count);  // 10
let name = null;
name ??= 'Anonymous';  // name is now 'Anonymous'
console.log(name);  // Anonymous

These shortcuts help you reduce the verbosity of your code.

7. Object.fromEntries()

If you’ve ever needed to convert a list of key-value pairs into an object, Object.fromEntries() makes it easy. It’s particularly useful when you’re working with Map objects or arrays of tuples.

Example:


const entries = [['name', 'Alice'], ['age', 25]];
const person = Object.fromEntries(entries);
console.log(person);  // { name: 'Alice', age: 25 }

This method is a cleaner, more readable alternative to manually constructing objects.

8. Array.prototype.flatMap()

This method is a combination of map() followed by flat(). It allows you to both map and flatten the results in a single step, which can be very useful when working with arrays of arrays.

Example:


const numbers = [1, 2, 3, 4];
const result = numbers.flatMap(x => [x, x * 2]);
console.log(result);  // [1, 2, 2, 4, 3, 6, 4, 8]

This is cleaner than performing a map() followed by flat() separately.

9. Array.prototype.at()

This new method makes it easy to access elements from the end of an array using negative indexes. It’s much more intuitive than manually calculating the index for the last item.

Example:


const arr = [10, 20, 30, 40, 50];
console.log(arr.at(2));  // 30
console.log(arr.at(-1)); // 50
console.log(arr.at(-2)); // 40

It simplifies working with the last items in an array.

10. Top-Level Await

In JavaScript, we’ve always had to use await inside an async function. But with top-level await, you can now use await directly at the top level of modules, making your asynchronous code more straightforward.

Example:


// In an ES Module (.mjs or type="module")
const response = await fetch('https://api.example.com/data');
const data = await response.json();
console.log(data);

This makes working with async code much simpler in modern JavaScript.

11. Private Class Fields

If you’ve ever wanted to make variables private in JavaScript classes, private class fields are now possible. You can now define variables that are not accessible from outside the class, using the # symbol.

Example:


class Person {
  #name;
  constructor(name) {
    this.#name = name;
  }
getName() {
    return this.#name;
  }
}
const person = new Person('John');
console.log(person.getName());  // John
This makes it easier to hide internal class details.

12. Stable Sort (Array.prototype.sort())

Previously, JavaScript’s sort() method was not stable, meaning equal items might be shuffled in an unpredictable way. Now, JavaScript ensures that elements with the same value retain their original order in the array.

Example:


const arr = [{ age: 30 }, { age: 20 }, { age: 30 }];
arr.sort((a, b) => a.age - b.age);
console.log(arr);  // [{ age: 20 }, { age: 30 }, { age: 30 }]

This ensures a more predictable and consistent sort of behaviour.

Conclusion

JavaScript continues to evolve, and these features bring both convenience and power to developers. Whether you’re working with asynchronous code, handling large numbers, or just cleaning up your object and array manipulations, these new features can help you write cleaner, more efficient code. If you haven’t already, start experimenting with them in your projects, and see how they can make your workflow smoother.

Happy coding! 🚀

Please follow me to get more valuable content

What is a flattened array and How do solving flatten array problem using recursion functions in JavaScript?

Sonu kumar — Tue, 23 Jul 2024 12:46:06 +0000

Introduction:

First Lets understand What is a flattened array. A flattened Array is an Array, but this array is a form of a multi-dimension array, a nested array or an array containing another array.

Flatten is one approach or technique that helps to reduce the multidimensional array to one one-dimensional array known as flatten.

Sometimes we require this kind of data when we are working on projects or solving a problem then it helps to pass the group of the data set using a flattened array.

Example:

// This is a flattened array
let arr = [1,44, [2, [3,9], 67], 9];

How to solve a flattened array problems?

There are multiple ways to solve this kind of problem but here, I am going to explain using the Recursion method, this is one of the best approaches to solve this kind of problem.

Here, I am not going to details explanation of the Recursion, But I will give a little overview of about, if you want to know more about I will create a separate post for that.

Recursion is a programming approach to solve the issues of repetition kinds of works, which calls itself directly or indirectly until not match the given particular conditions, if matched then the function stops the calling itself.

 // This is a flattened array
// Input:
  let arr = [1,44, [2, [3,9], 67], 9];

  // Function Defin 
  function recur(a) {
    let newArr = [];
    for (let i =0 ; i < a.length; i++) {
        const element = a[i];
        if (Array.isArray(element)) {
            // Function calling itself recursion
            newArr.push(...recur(element))
        } else  {
            newArr.push(element)
        }
    }

    return newArr;
  }

console.log(recur(arr))
Output:
[1,44,2,3,9, 67, 9]

// We can also write the same code using for each:
function flattenArray(items) {
    const flat = [];
    items.forEach(item => {
      if (Array.isArray(item)) {
        flat.push(...flatten(item));
      } else {
        flat.push(item);
      }
    });

    return flat;
  }

onsole.log(flattenArray(arr))
output:
[1,44,2,3,9, 67, 9]

What is the difference between a deep copy and a shallow copy in JavaScript?

Sonu kumar — Sat, 06 Jul 2024 09:12:34 +0000

Deep Copy And Shallow Copy:

Sometimes we need to copy the value from one variable to another variable is known as copy. But when we are copying the value from one variable to another variable that means we are copying the reference of that variable, which means we are not creating the new variable for that just assigned the reference of the variable.

So when we made the changes on the copied variable object/ array it also gets changes on the original variable value, which is known as Shallow Copy if when are any changes on the copied variable then not getting any changing the original variable values are known as Deep Copy

Example: how to make the deep copy and shallow copy:

//original
  var userObj = {
    name: "Jhon",
    address:{
      City: {
        name: "Noida"
      }
    }
  }

  //wanted to copy
  var copyUserObj = userObj; // shallow copy

  ///Here we are doing the changes:
  copyUserObj.name = "jhon de-costa"

  console.log(userObj);
  output:
  {
    "name": "Jhon De-costa",
    "address": {
      "city": {
        "name": "Noida"
      }
    }
  }


  To avoid these things we deep copy using the ES6 spread operator:

  copyUserObj = {...userObj}

  copyUserObj.name = "jhon de-costa"


  console.log(userObj)
  output:
   {
    name: "Jhon",
    address:{
      City: {
        name: "Noida"
      }
    }
  }


  console.log(copyUserObj)
  output:
   {
    "name": "Jhon De-costa",
    "address": {
      "city": {
        "name": "Noida"
      }
    }
  }


  Ex:2
  var arr1 = [1, 2, 4]

  //Wanted to copy here array to arr2
  var arr2 =  arr1;

  arr2[1] = 4
  console.log(arr1);


  output:
  [1,4,4]


  //deep copy using spred {...} oprator 

  arr2= [...arr1];

  console.log(arr2)
  output:
  [1,2,4]

  //after modifcation of arr2 the value 

  var arr2 = [1,4,4]
  console.log(arr1)

  output:
  [1,2,4]

  console.log(arr2)

  output:
  [1,4,4]


  If you have any doubts please comment I will clear your doubts;

How to Install and Manage Multiple Node.js Versions on macOS Using NVM

Sonu kumar — Thu, 27 Jun 2024 04:02:15 +0000

As a developer working with Node.js, we might need to work on various projects and each project has its configuration. So maybe some of the projects have different versions of Node.js, and then we need to switch between different versions of Node.js for multiple projects. The Node Version Manager (NVM) is a fantastic tool that makes this process easier. In this guide, we'll cover three ways to install NVM on macOS and show you how to manage multiple Node.js versions with ease.

What is NVM?

NVM is a version manager for Node.js, designed to simplify the installation and management of multiple Node.js versions on a single machine. With NVM, you can easily switch between different versions of Node.js as per your project's requirements.

Prerequisites

Before we start, ensure you have the following:

A macOS machine ( This method support for all versions of macOS including M1, M2 and Intel)
Command Line Tools (you can install them by running xcode-select - install in the Terminal) Now, let's explore the three ways to install NVM on macOS:

Method 1: Installing NVM Using the Curl Command

This is the recommended method from the official NVM GitHub repository.

Open Terminal: Launch the Terminal application on your macOS.
Download and Install NVM: Run the following command to download and install NVM:

 curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash

Load NVM: After installation, you need to load NVM into your current terminal session. Add the following lines to your shell profile file (e.g., .zshrc for Zsh or .bash_profile for Bash):

export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
 [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

Apply Changes: Run the following command to apply the changes:

source ~/.zshrc

Verify Installation: Check if NVM is installed correctly by running:

nvm - version

Method 2: Installing NVM Using Homebrew

Homebrew is a popular package manager for macOS.

Open Terminal: Launch the Terminal application.
Install Homebrew (if not already installed):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Install NVM with Homebrew: Run the following command to install NVM:

brew install nvm

Create NVM Directory: Create a directory for NVM:

 mkdir ~/.nvm

Load NVM: Add the following lines to your shell profile file (e.g., .zshrc or .bash_profile):

export NVM_DIR="$HOME/.nvm"
 . "$(brew - prefix nvm)/nvm.sh"

Apply Changes: Run the following command to apply the changes:

source ~/.zshrc

Verify Installation: Check if NVM is installed correctly by running:

nvm - version

Method 3: Installing NVM Using MacPorts

MacPorts is another package management system for macOS.

Open Terminal: Launch the Terminal application.
Install MacPorts (if not already installed): - Download and install MacPorts from the official MacPorts website.
Install NVM with MacPorts: Run the following command to install NVM:

sudo port install nvm

Load NVM: Add the following lines to your shell profile file (e.g., .zshrc or .bash_profile):

export NVM_DIR="$HOME/.nvm"
 . /opt/local/share/nvm/init-nvm.sh

Apply Changes: Run the following command to apply the changes:

source ~/.zshrc

Verify Installation: Check if NVM is installed correctly by running:

nvm - version

Managing Multiple Node.js Versions with NVM

Now that you have NVM installed, let's see how you can manage multiple Node.js versions.

Installing a Specific Node.js Version

To install a specific version of Node.js, use the following command:

nvm install <version>

For example, to install Node.js version 14.17.0:

nvm install 14.17.0

Listing Installed Node.js Versions

To list all installed Node.js versions, run:

nvm ls

Switching Between Node.js Versions

To switch to a specific version of Node.js, use the following command:

nvm use <version>

For example, to switch to Node.js version 14.17.0:

nvm use 14.17.0

Setting a Default Node.js Version

To set a default Node.js version, which will be used whenever you open a new terminal session, run:

nvm alias default <version>

For example, to set Node.js version 14.17.0 as the default:

nvm alias default 14.17.0

Conclusion
With NVM, managing multiple Node.js versions on macOS is a breeze. Whether you choose to install NVM using the curl command, Homebrew, or MacPorts, you now have the tools to easily switch between Node.js versions and ensure your projects run smoothly. Happy coding!

Simplified Guide to Installing NVM on Ubuntu

Sonu kumar — Wed, 26 Jun 2024 12:13:47 +0000

Introduction

Managing multiple versions of Node.js on your Ubuntu system is crucial for development. Node Version Manager (NVM) simplifies this process, allowing you to switch between different versions effortlessly.

Step-by-Step Installation

Update Your System:

   sudo apt update

Install Curl:

   sudo apt install curl

Download and Install NVM:

   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Activate NVM:

   export NVM_DIR="$([ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm")"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm

Verify NVM Installation:

   nvm --version

Install Node.js Using NVM:

   nvm install node

Set Default Node.js Version:

   nvm alias default node

Check Installed Node.js Version:

   node --version

Managing Node.js Versions

Install Specific Version:

  nvm install <version>

Switch Node.js Version:

  nvm use <version>

List Installed Versions:

  nvm ls

Uninstall Node.js Version:

  nvm uninstall <version>

Conclusion

Using NVM on Ubuntu provides flexibility and control over your Node.js environment, making development smoother and more efficient.

To know how to install the NVM on Windows please have a look:
How to install NVM(Node Version Manager) on Windows

To learn about the Docker basics please have a look:
What is Docker and why do we use it?

Understanding Linux Permissions and Ownership

Sonu kumar — Wed, 26 Jun 2024 04:02:08 +0000

Linux is a powerful operating system, and one of its core features is its robust permissions and ownership model. Understanding how to manage these permissions and ownership is crucial for maintaining system security and ensuring proper access control. In this blog post, we'll break down Linux permissions and ownership, explaining why and when you should use them, along with easy-to-understand examples.

What are Linux Permissions?

Linux permissions determine who can read, write, or execute a file. Every file and directory in Linux has three types of permissions:

Read (r): Allows viewing the contents of a file or listing a directory.
Write (w): Allows modifying the contents of a file or adding/removing files in a directory.
Execute (x): Allows running a file as a program or accessing a directory.

These permissions are assigned to three categories of users:

Owner: The user who owns the file.
Group: A set of users who share access rights to the file.
Others: Everyone else who has access to the system.

Understanding the Permission Notation

Permissions are often represented in a shorthand notation, such as rwxr-xr--. Here’s how to read it:

The first character indicates the type (- for a file, d for a directory).
The next three characters (rwx) are the owner's permissions.
The middle three characters (r-x) are the group's permissions.
The last three characters (r--) are the others' permissions.

Viewing Permissions

To view the permissions of a file or directory, use the ls -l command.

ls -l file_name

Example output:

-rwxr-xr--

This output shows that the owner can read, write, and execute the file, the group can read and execute, and others can only read.

Changing Permissions with `chmod`

The chmod command is used to change the permissions of a file or directory. You can use symbolic or numeric modes to set permissions.

Symbolic Mode

Symbolic mode uses letters to represent permissions and users:

u (user/owner)
g (group)
o (others)
a (all)

To add, remove, or set permissions, use +, -, or = respectively.

Example:

chmod u+x file_name

This command adds execute permission for the owner.

Numeric Mode

Numeric mode uses a three-digit octal number to represent permissions. Each digit ranges from 0 to 7, representing the sum of the permissions:

4 for read (r)
2 for write (w)
1 for execute (x)

Example:

chmod 755 file_name

This command sets the permissions to rwxr-xr-x, where the owner has full permissions, and the group and others have read and execute permissions.

Ownership in Linux

Every file and directory in Linux has an owner and a group associated with it. This helps manage who can access and modify files.

Viewing Ownership

To view the ownership of a file or directory, use the ls -l command.

ls -l file_name

Example output:

-rwxr-xr-- 1 owner_name group_name file_name

This output shows the owner (owner_name) and the group (group_name).

Changing Ownership with `chown`

The chown command changes the ownership of a file or directory.

chown new_owner file_name

To change both owner and group, use:

chown new_owner:new_group file_name

Example:

chown alice:developers project_code.py

This command sets the owner to alice and the group to developers.

Changing Group with `chgrp`

The chgrp command changes the group ownership of a file or directory.

chgrp new_group file_name

Example:

chgrp developers project_code.py

This command sets the group to developers.

Why and When to Use Permissions and Ownership

Security: Properly setting permissions and ownership helps protect sensitive files from unauthorized access. For example, configuration files should be readable and writable only by the owner.

chmod 600 config_file

Collaboration: When working on projects with others, setting group permissions allows team members to collaborate without compromising security. For instance, a shared directory for a development team:

chmod 770 shared_directory
chown :developers shared_directory

Executable Files: Scripts and programs need execute permissions to run. For example, making a script executable:

chmod +x script.sh

Web Servers: Web server files should be readable by the server but not writable by the web service user, preventing unauthorized modifications.

chmod 644 index.html
chown www-data:www-data index.html

Conclusion

Understanding and managing Linux permissions and ownership is essential for maintaining system security and ensuring proper access control. By mastering these concepts, you can keep safe your files, collaborate effectively, and manage your system more efficiently and secure. Practice these commands regularly to become proficient in handling permissions and ownership in Linux.

Essential Linux Commands for Daily Use as a Developer

Sonu kumar — Wed, 26 Jun 2024 03:58:33 +0000

As a software developer, mastering Linux commands can significantly enhance your productivity and streamline your workflow. Whether you're managing files, navigating directories, or automating tasks, Linux offers a robust set of commands that are invaluable for daily use. In this blog post, we'll cover some of the most essential Linux commands every developer should know, with examples to illustrate their use.

1. Navigating the File System

ls: List Directory Contents

The ls command is used to list the files and directories in the current directory. It's one of the most frequently used commands in Linux.

ls

You can also use options to modify its behavior, such as -l for a detailed list and -a to show hidden files.

ls -la

cd: Change Directory

The cd command allows you to navigate between directories.

cd /path/to/directory

To go back to the previous directory, use:

cd -

To go to your home directory, simply use:

cd

2. Managing Files and Directories

cp: Copy Files and Directories

The cp command is used to copy files and directories.

cp source_file destination_file

To copy an entire directory, use the -r option:

cp -r source_directory destination_directory

mv: Move or Rename Files and Directories

The mv command moves or renames files and directories.

mv old_name new_name

To move a file to a different directory:

mv file_name /path/to/destination

rm: Remove Files and Directories

The rm command is used to delete files and directories.

rm file_name

To delete a directory and its contents, use the -r option:

rm -r directory_name

Use caution with the rm command, especially with the -r option, as it permanently deletes files.

3. Viewing and Editing Files

cat: Concatenate and Display Files

The cat command displays the contents of a file.

cat file_name

For larger files, cat can be combined with less for easier reading:

cat file_name | less

nano: Text Editor

nano is a simple, user-friendly text editor.

nano file_name

To save your changes in nano, press CTRL + O, and to exit, press CTRL + X.

grep: Search Text Using Patterns

The grep command searches for a specific pattern within files.

grep 'search_term' file_name

To search recursively through directories, use the -r option:

grep -r 'search_term' /path/to/directory

4. System Information and Management

top: Display Active Processes

The top command provides a real-time view of the system's processes, showing CPU and memory usage.

top

To exit top, press q.

df: Disk Space Usage

The df command displays disk space usage for all mounted filesystems.

df -h

The -h option makes the output human-readable.

free: Memory Usage

The free command shows the system's memory usage.

free -h

The -h option again makes the output human-readable.

5. Networking

ping: Test Network Connectivity

The ping command checks the connectivity between your system and another host.

ping www.example.com

Press CTRL + C to stop the pinging process.

curl: Transfer Data from or to a Server

The curl command is used to transfer data from or to a server, using various protocols.

curl http://www.example.com

To download a file, use:

curl -O http://www.example.com/file.txt

6. Permissions and Ownership

chmod: Change File Permissions

The chmod command modifies file permissions.

chmod 755 file_name

This sets the permissions to rwxr-xr-x, where the owner has full permissions, and others have read and execute permissions.

chown: Change File Owner

The chown command changes the owner of a file or directory.

chown user:group file_name

To change ownership recursively, use the -R option:

chown -R user:group directory_name

7. Combining Commands

&&: Run Multiple Commands Sequentially

You can combine multiple commands using && to run them sequentially.

cd /path/to/directory && ls

This command changes the directory and then lists its contents.

| (Pipe): Pass Output from One Command to Another

The pipe | is used to pass the output of one command as input to another.

ls | grep 'search_term'

This command lists the directory contents and then searches for a specific term.

Conclusion

Knowing these fundamental Linux commands will make your daily tasks as a software developer much easier. From managing files and directories to viewing system information and handling network tasks, these commands form the backbone of your interaction with the Linux operating system. Practice using them regularly to improve your efficiency and become more proficient with Linux.

How to install NVM(Node Version Manager) on Windows

Sonu kumar — Tue, 25 Jun 2024 07:46:54 +0000

NVM is a Node Version Manager used to manage multiple Node.js versions on systems.

Why NVM Need?

NVM makes it easy to install and manage different Node versions on your machine or laptop, and you can switch between them whenever you need it from one node version to another based on your need. To switch to another version of node.js, you have to run a few commands, which I will explain in the below sections.

Suppose you have installed the specific version of node 18.0.0 on your machine, and you will get another project that project needs a higher or lower version of node.js (either node version 20.0.0 or 16.0.0 )to run the project on your machine but your system has node 18.0.0. So when you try to install packages and run the project you will get the Node version.

In the following sections, I’ll guide you through installing NVM on your Windows, Linux, or Mac device.

Before proceeding, I recommend uninstalling Node.js if you installed it to avoid conflicts between Node.js and NVM.

Installing NVM on Windows

NVM is primarily supported on Linux and Mac, but not on Windows. However, there’s a similar tool called nvm-windows created by Corey Butler, which provides a similar experience for managing Node.js versions on Windows.

Below are the steps on how to install nvm-windows:

1. Download nvm-windows:

Go to the nvm-windows repository README file and click on the Download Now button, Or you can click here to Download. This will take you to a page with various NVM releases.

Download the NVM for Windows

Install the .exe file: Once you are redirected to the release page (currently version 1.1.12) click on nvm-setup.exe and it downloads the nvm-windows on your machine.

Run the installer:
Open the downloaded file and follow the prompts to complete the installation wizard.
Verify the installation:
After installation, open a command prompt and run:

nvm -v

If everything is installed correctly, this command will display the installed NVM version.

NVM Commands for switching between Node versions:

To view available Node versions, run the following command:

nvm list

Now you can see what the list of node versions available in the machine looks like,

If you want to select a specific version of the node.js that version is in the above list (screenshot image). Then run the below commands to select the particular node version and press enter.

Here I am selecting node version 14.17.1

nvm use v14.17.1

Verified selected node version:

node -v

then you will see the selected node version instead of the default one, here I have selected node 14 so it will show nod 14 for me.

What happens if the specified version of the node is not available then we have to install it using nvm command and then select it from the above steps.

To install a specific node version:

nvm install 20.0.0

Thank you for reading our article, I have tried to cover the all-important command and steps for more details visit the nvm-windows

Please like follow and share, I need your support!!
Thank you!!

Follow Me on:
Linkedin
Medium
X(formally known as Twitter)

What is Docker and why do we use it?

Sonu kumar — Mon, 24 Jun 2024 12:28:54 +0000

What is Docker?

Docker is a free software tool that helps you build, test, and deploy applications quickly. It allows you to manage your application’s infrastructure just like you manage software on your computer. This makes it easy to move your application between different computers or environments without worrying about compatibility issues.

Why do use Docker?

With Docker, you can manage your applications and setup just like you manage programs and applications on your own computer. It means you can easily set up, run and test your applications on a personal laptop and cloud machine without any compatibility and environment issues. Docker simplifies the process of getting your applications up and running, making development and deployment very easy.

Docker’s Origin

Docker was developed and created by ‘Solomon Hykes’ in March 20, 2013, For more details visit the Git repository: and Docker's official website Docker.

What is Infrastructure?

I hope you know about it, but if you don’t, I will explain it to you. Infrastructure is simply a setup of tools, software, and other necessary elements that are needed to run an application. This setup, which includes all the hardware, software, and connections, is known as infrastructure.

What is a Docker Container?

Docker is using a technology called OS-level virtualization, which allows you to create “containers.”

A container is like a small, lightweight package of docker that includes everything your application needs to run, such as code, libraries, and settings. This way, you can be sure your application will work the same way everywhere, whether it’s on your computer, someone else’s, or even on servers in the cloud.

In simple terms, Docker makes it easier to develop, test, and deploy applications by putting them in these handy containers, ensuring they run consistently no matter where they are used.

What is a Docker engine?

A Docker Engine is a part of Docker and it is hosted the Containers is called the Docker Engine. Docker Engine acts as client-server with:

A docker engine is running the daemon process docked
A docker Engine provides APIs, which specify an interface to talk with the Docker daemon.
A docker Engine provides the command line interface (CLI)
client to communicate with Docker and their packages.
For more details: Docker Engine

What is Docker Desktop?

A Docker Desktop is a docker tool that provides the Graphical User Interface (GUI), where you can see and manage the containers, applications, images, networks and volumes from your computers.
You can download and install the Docker Desktop

What is Docker Compose?

Docker Compose is a tool that makes it easy to run applications with multiple containers. It helps streamline both development and deployment processes.

With Docker Compose, you define your entire application setup, including services, networks, and storage, in one simple YAML file. This file describes how all parts of your application work together. Then, with just one command, you can start up everything based on this configuration.

Compose is versatile and works in all stages of development, including production, staging, development, testing, and continuous integration (CI). It offers commands to manage your application’s lifecycle, such as:

Starting, stopping, and rebuilding services
Checking the status of running services
Viewing live logs of running services
Running specific commands on any service

What is Docker Build?

Docker Build is a crucial feature of Docker Engine. It’s used whenever you create a Docker image, which is a package containing your application and everything it needs to run.

Docker Build isn’t just a simple command; it’s an entire system designed to help you package, bundle, and ship your code efficiently. It plays a vital role in the software development process, making it easy to create consistent, portable application images.

With Docker Build, you get a range of tools and features that support both basic and advanced tasks. Whether you’re just getting started or working on complex projects, Docker Build helps streamline your workflow and ensure your applications are ready to run anywhere.

For more details visit the Docker

This is Part 1 of an overview of Docker and its components. In Part 2, I will share how to install and set up Docker with examples. Stay tuned for complete tutorials with examples. Please like, follow, and share this post!

Please Follow me:
Dev
LinkedIn

DEV Community: Sonu kumar

How to Install Cursor AI Editor on Linux, Ubuntu (2025 Update)

Step-by-Step Installation Guide

Step 1:

Step 2:

Step 3:

Step 4:

Step 5: Install FUSE by running:

Step 6:

Step 7: Run the AppImage file:

Adding Cursor to Your Applications List

Final Step:

Understanding Bubble Sort Algorithm: A Step-by-Step Guide

What is Bubble Sort?

JavaScript Implementation:

Output

Sorting with Descding Orders:

Output:

How it works:

Optimized Version:

Explanations:

Time Complexity

Conclusion

[Boost]

12 New JavaScript Features Every Developer Should Know

Sonu kumar ・ Dec 21 '24

12 New JavaScript Features Every Developer Should Know

1. Optional Chaining (?.)

Example:

2. Nullish Coalescing Operator (??)

Example

3. Promise.allSettled()

Example:

4. BigInt for Large Numbers

Example:

5. String.prototype.replaceAll()

Example:

6. Logical Assignment Operators (&&=, ||=, ??=)

Example:

7. Object.fromEntries()

Example:

8. Array.prototype.flatMap()

Example:

9. Array.prototype.at()

Example:

10. Top-Level Await

Example:

11. Private Class Fields

Example:

12. Stable Sort (Array.prototype.sort())

Example:

Conclusion

What is a flattened array and How do solving flatten array problem using recursion functions in JavaScript?

Introduction:

How to solve a flattened array problems?

What is the difference between a deep copy and a shallow copy in JavaScript?

Deep Copy And Shallow Copy:

How to Install and Manage Multiple Node.js Versions on macOS Using NVM

What is NVM?

Prerequisites

Method 1: Installing NVM Using the Curl Command

Method 2: Installing NVM Using Homebrew

Method 3: Installing NVM Using MacPorts

Managing Multiple Node.js Versions with NVM

Installing a Specific Node.js Version

Listing Installed Node.js Versions

Switching Between Node.js Versions

Setting a Default Node.js Version

Simplified Guide to Installing NVM on Ubuntu

Introduction

Step-by-Step Installation

Managing Node.js Versions

Conclusion

Understanding Linux Permissions and Ownership

What are Linux Permissions?

Understanding the Permission Notation

Viewing Permissions

Changing Permissions with chmod

Ownership in Linux

Viewing Ownership

Changing Permissions with `chmod`

Changing Ownership with `chown`

Changing Group with `chgrp`