Forem: vinayak

The Bcrypt Algorithm for Secure Password Hashing

vinayak — Sun, 08 Dec 2024 16:53:25 +0000

Hashing is a cryptographic function that cannot be reversed. It takes an input of random size to produce fixed-size values. These fixed-size values are called hash values, and the cryptographic function is called the hashing function. Hashing has a consistent and predictable nature, meaning the same input will always produce the same hash value. It also exhibits the avalanche effect , which means even a slight change in the input results in a drastically different hash value, ensuring high security and uncertainty.

Hashing often employs salted hashing, where a unique random string called salt is added to the input before hashing, making each hash unique even for identical inputs

Salted hashing is primarily used in password hashing. One such algorithm is the bcrypt algorithm.

Bcrypt Algorithm

The Bcrypt algorithm is based on the Blowfish encryption algorithm. bcrypt generates a unique salt (random string) for each password, and then the salt is combined with the password before hashing. This makes Bcrypt resistant to brute-force attacks.

How Bcrypt Works

Generating Salt:
Bcrypt generates a random salt that is 16 bytes long and typically in Base64 format.
Hashing the given string:
The salt is combined with the password, and the resulting string is passed through the Blowfish encryption algorithm. bcrypt applies multiple rounds of hashing defined by the work factor. The high number of rounds makes it computationally expensive, which enhances its resistance to brute-force attacks.
The work factor, also known as cost, is defined by the logarithmic value of 2. If the cost is 12, this means 2^12 rounds. The higher the cost factor, the more time it takes to generate a hash, which in turn makes it harder for attackers to brute-force passwords.
Format and Length of Bcrypt Hash:

 $2y$12$odwBFokG9vTK/BAaRXKKl.9Q8KHXHeYSqpLi/gSNpmzSwQcaJb.gS

The given string consists of:

$2y$ : bcrypt version
12 is the cost factor (2^12 rounds)
The next 22 characters (odwBFokG9vTK/BAaRXKKl.) are Base64-encoded salt
The remaining characters are the Base64-encoded hash of the password and salt.

Python Implementation of Bcrypt Algorithm

Required Dependencies

import hashlib
import os
import base64

Class Initialization

class Bcrypt:
    def __init__(self, rounds=12, salt_length=22):
        self.rounds = rounds
        self.salt_length = salt_length

Bcrypt class encapsulates the functionality to hash and verify passwords
Parameters:

Generating a Salt

def generate_salt(self, salt_length=None):
        if salt_length is None:
            salt_length = self.salt_length
        return base64.b64encode(os.urandom(salt_length)).decode('utf-8')[:salt_length]

Function generate_salt creates a random salt, which will be a unique value that will be added to passwords to ensure that even identical passwords produce different hashes.

Hashing a Password

def bcrypt_hash(self, password, salt, cost):
    password_salt = f'{password}{salt}'
    password_salt = password_salt.encode('utf-8')
    hashed_password_salt = hashlib.sha256(password_salt).hexdigest()
    for _ in range(2**cost):
        hashed_password_salt = hashlib.sha256(hashed_password_salt.encode('utf-8')).hexdigest()
    return hashed_password_salt

def hash_password(self, password, salt_length=None, cost=None):
    if salt_length is None:
        salt_length = self.salt_length
    if cost is None:
        cost = self.rounds
    salt = self.generate_salt(salt_length)
    hashed_password = self.bcrypt_hash(password, salt, cost)
    return f'{cost}${salt}${hashed_password}'

Function bcrypt_hash securely hashes the password with the provided salt and cost factor.
and Function hash_password generates a secure hash for the given password with a random salt.

Code:

import hashlib
import os
import base64



class Bcrypt:
    def __init__(self, rounds=12, salt_length=22):
        self.rounds = rounds
        self.salt_length = salt_length

    def generate_salt(self, salt_length=None):
        if salt_length is None:
            salt_length = self.salt_length
        return base64.b64encode(os.urandom(salt_length)).decode('utf-8')[:salt_length]

    def bcrypt_hash(self, password, salt, cost):
        password_salt = f'{password}{salt}'
        password_salt = password_salt.encode('utf-8')
        hashed_password_salt = hashlib.sha256(password_salt).hexdigest()
        for _ in range(2**cost):
            hashed_password_salt = hashlib.sha256(hashed_password_salt.encode('utf-8')).hexdigest()
        return hashed_password_salt

    def hash_password(self, password, salt_length=None, cost=None):
        if salt_length is None:
            salt_length = self.salt_length
        if cost is None:
            cost = self.rounds
        salt = self.generate_salt(salt_length)
        hashed_password = self.bcrypt_hash(password, salt, cost)
        return f'{cost}${salt}${hashed_password}'

    def verify_password(self, password, hashed_password):
        cost, salt, hashed_password = hashed_password.split('$')
        cost = int(cost)
        return hashed_password == self.bcrypt_hash(password, salt, cost)



bcrypt = Bcrypt()
password = 'vinayak'
hashed_password = bcrypt.hash_password(password)
print('string :', password, ' bcrypt hash :', hashed_password)
print('verify password :', bcrypt.verify_password(password, hashed_password))
print('verify invalid password :', bcrypt.verify_password('vinayak1', hashed_password))

Output:

python test.py
string : vinayak  bcrypt hash : 12$FxJAsfQ2+7WuMj+ZGPAdFE$546a20a2ad890186ab661cb4969e8651a6f75eb5d4ffa0706ba4153414b65ea5
verify password : True
verify invalid password : False

Getting started with RabbitMq using NodeJs

vinayak — Thu, 05 Sep 2024 21:13:55 +0000

Introduction to RabbitMq

RabbitMq is a message broker that allows sending and receiving messages between different services. It is a message broker that implements the Advanced Message Queuing Protocol (AMQP). Written with Erlang Programming Language.

Installing RabbitMq

RabbitMq can be installed on different operating systems Using there respective package managers. RabbitMQ requires Erlang/OTP to be installed beforehand, please refer to the official documentation for more information.

Linux

sudo apt-get install rabbitmq-server

brew install rabbitmq

Once installed, we can start the RabbitMq server using the following command:

sudo rabbitmq-server

Once the server is started, we can access rabbitmq from our application using the default port 5672.

To enable the RabbitMq management console, we can run the following command:

sudo rabbitmq-plugins enable rabbitmq_management

we can access the RabbitMq management console by visiting http://localhost:15672/ in your browser. The default username and password are guest.

Setting up RabbitMq with NodeJs

To interact with RabbitMq from NodeJs, we can use the amqplib library. We can install the library using the following command:

npm install amqplib

To connect to RabbitMq from NodeJs and create a channel to interact with RabbitMq, we can use the following code:

const amqp = require("amqplib");

const connect = async (url) => {
  const connection = await amqp.connect(url);
  const channel = await connection.createChannel();

  return channel;
};

connect("amqp://localhost:5672").then((channel) => {
  console.log("Connected to RabbitMQ");
  channel.close();
  process.exit(0);
});

Now, we have a channel to interact with RabbitMq. We can use this channel to send and receive messages from RabbitMq. let name our queue mq-test-queue and send a message to the queue.

connect("amqp://localhost:5672").then((channel) => {
  console.log("Connected to RabbitMQ");
  channel.assertQueue("mq-test-queue");
  console.log("Queue created");
  channel.sendToQueue("mq-test-queue", Buffer.from("Hello World!"));
  console.log("Message sent");
});

We have created a queue mq-test-queue and sent a message Hello World! to the queue. To create a Queue, we have used the assertQueue method and to send a message to the queue, we have used the sendToQueue method.

To receive a message from the queue, we can use the consume method.

connect("amqp://localhost:5672").then((channel) => {
  console.log("Connected to RabbitMQ");
  channel.assertQueue("mq-test-queue");
  console.log("Queue created");
  channel.sendToQueue("mq-test-queue", Buffer.from("Hello World!"));
  console.log("Message sent");
  channel.consume("mq-test-queue", (msg) => {
    console.log("Message received", msg.content.toString());
  });
});

The consume method takes a callback function and passes the message object to the callback function to access the message content using msg.content.toString().

After consuming the message, we need to ack or nack the message to remove the message from the queue. We can use the ack method to acknowledge the message and the nack method to reject the message.

For this example, we will ack the message after consuming the message.

const amqp = require("amqplib");

const connect = async (url) => {
  const connection = await amqp.connect(url);
  const channel = await connection.createChannel();

  return channel;
};

connect("amqp://localhost:5672").then((channel) => {
  console.log("Connected to RabbitMQ");
  channel.assertQueue("mq-test-queue");
  console.log("Queue created");
  channel.sendToQueue("mq-test-queue", Buffer.from("Hello World!"));
  console.log("Message sent");
  channel.consume("mq-test-queue", (msg) => {
    console.log("Message received", msg.content.toString());
    channel.ack(msg);
  });
});

We can see messages sent and received successfully from the queue. using rabbitmq management console.

Conclusion

In this article, we have learned how to set up RabbitMq and interact with RabbitMq from NodeJs using the amqplib library. We have created a queue, sent a message to the queue, and received a message from the queue.

Redis Pipelining in NodeJS

vinayak — Thu, 25 Jul 2024 18:35:19 +0000

Redis Pipelining is a technique that helps to reduce the round-trip time between the Redis server and the client. In this article, we will explore the Redis Pipelining in Node.js.

Before we start, let's first understand the time between round trips involved in executing Redis commands between the server and client.

The client sends a Redis query to the Redis server.

The Redis server processes this query and responds to the client.

For each Redis command, this request-response cycle continues.

MULTI Command In Redis

The MULTI command in the Redis allows the execution of multiple Redis commands in a single step.

Syntax

Using Redis Multi and Pipeline in NodeJS

In Node.js, Redis clients have two main methods for batching commands and creating transactions. One is the Redis multi command, mentioned above, and the other is the pipeline method.

In this article, we will be using the node-redis package.

Install

npm i redis

Multi with node-redis

The MULTI command in Redis executes a group of commands as atomic transactions to ensure data integrity. This means that all commands in the block are either executed or none are.

Redis example of multi

const redis = require("redis");

const client = redis.createClient();

const execMulti = () => {
  const multi = client.multi();
  multi.set("key1", "value1");
  multi.set("key2", "value2");
  multi.get("key1");
  multi.get("key2");
  const multiExec = multi.exec();

  multiExec
    .then((res) => {
      console.log("Multi commands executed successfully");
      console.log(res);
      client.quit();
    })
    .catch((err) => {
      console.log("Error executing multi commands");
      console.log(err);
    });
};

client.on("error", (err) => {
  console.log("Redis Client Error", err);
});

client
  .connect()
  .then(() => {
    console.log("Connected to Redis");
    execMulti();
  })
  .catch((err) => {
    console.log(err);
  });

Pipeline with node-redis

The pipeline feature of the node-redis client allows batching of multiple commands but does not guarantee atomicity.

Node Redis can automatically group multiple requests made during the same "tick, " meaning if commands are in a single cycle of the event loop, the node-redis client can combine them into a single pipeline.

Auto-Pipelining example in Node Redis

const redis = require("redis");
const client = redis.createClient();

client.on("error", (err) => {
  console.error("Redis client error", err);
});

client
  .connect()
  .then(() => {
    console.log("Connected to Redis");
    Promise.all([
      client.set("key", "value"),
      client.get("key"),
      client.set("key1", 1),
      client.incr("key1"),
      client.get("key1"),
    ])
      .then((results) => {
        console.log("SET", results[0]);
        console.log("GET", results[1]);
        console.log("SET", results[2]);
        console.log("INCR", results[3]);
        console.log("GET", results[4]);
        client.quit();
      })
      .catch((err) => {
        console.error("Error setting/getting from Redis", err);
      });
  })
  .catch((err) => {
    console.error("Error connecting to Redis", err);
  });

Output

Connected to Redis
SET OK
GET value
SET OK
INCR 2
GET 2

Node-redis client also contains execAsPipeline() method for manual batching of redis commands

Example using execAsPipeline method

const redis = require("redis");
const client = redis.createClient();

client.on("error", (err) => {
  console.error("Redis client error", err);
});

client
  .connect()
  .then(async () => {
    console.log("Connected to Redis");
    let pipeline = client.multi();
    pipeline.set("key1", "value1");
    pipeline.set("key2", "value2");
    pipeline.get("key1");
    pipeline.get("key2");
    let result = await pipeline.execAsPipeline();
    console.log(result);
    client.quit();
  })
  .catch((err) => {
    console.error("Error connecting to Redis", err);
  });

output

Connected to Redis
[ 'OK', 'OK', 'value1', 'value2' ]

Date Function in Javascript

vinayak — Sun, 21 Apr 2024 09:45:20 +0000

Using the Date function without the 'new' keyword will give you a string showing the current date and time. but it does not have all the features of a complete Date object. using it with the 'new' keyword. The Date object instance is created with all functionalities.

Optimizing Your Development Workflow with Bash Scripts!

vinayak — Wed, 20 Dec 2023 16:17:56 +0000

Open Git Repository:

git remote get-url origin | xargs open

The command retrieves the URL of the "origin" remote repository and opens it in the default web browser. This is useful when you want to quickly visit the remote repository's webpage without having to manually copy and paste the URL into the browser.

Kill Process by Port:

# lsof -i tcp:8080 | awk 'FNR == 2{print $2}' | xargs kill -9

 function killByPort {
        local port=$1
        echo "killing port ${port}"
        lsof -i tcp:${port} | awk 'FNR == 2{print $2}' | xargs kill -9
        echo "done . . . "
}


killByPort $1


## use : sh killByPort.sh {port}
# port -> 2020, 8000

The provided script is a Bash shell script designed to kill a process running on a specified port number.

Backup Script:

#!/bin/bash

function backup {
    local backup_dir="$1"
    local source_dir="$2"

    # Check if source directory/file exists
    if [ ! -e "$source_dir" ]; then
        echo "Error: Source directory/file '$source_dir' not found."
        exit 1
    fi

    # Create backup directory if it doesn't exist
    if [ ! -d "$backup_dir" ]; then
        mkdir -p "$backup_dir"
    fi

    local timestamp=$(date +%Y%m%d%H%M%S)
    local backup_filename="backup_$timestamp.tar.gz"

    tar -czf "$backup_dir/$backup_filename" "$source_dir"
    echo "Backup created: $backup_filename"
}

# Usage: backup <backup_directory> <source_file_or_directory>
backup "./backup" "./example.txt"

This script can be used to create a backup of specified files or directories.

Disk Space Checker:

#!/bin/bash

function disk_space {
    local partition=$1
    local disk_space=$(df -h $partition | awk 'NR==2 {print $4}')
    echo "Available disk space on $partition: $disk_space"
}

disk_space /

This script checks the available disk space on the system.

File Cleanup Script:

#!/bin/bash

function clean_old_files {
    local directory=$1
    local days_old=$2

    find "$directory" -type f -mtime +$days_old -exec rm {} \;
    echo "Old files deleted."
}

clean_old_files "/home/username/Downloads" 30

This script deletes files older than a specified number of days in a directory.

Find and Replace in Files:

function search_and_replace {
    local search_string="$1"
    local replace_string="$2"
    local directory="$3"

    grep -rl "$search_string" "$directory" | xargs sed -i "s/$search_string/$replace_string/g"
    echo "String '$search_string' replaced with '$replace_string' in files under '$directory'."
}

The script you provided defines a Bash function search_and_replace that takes three arguments: search_string, replace_string, and directory. It searches for files containing the search_string in the specified directory and replaces all occurrences of search_string with replace_string in those files using sed -i

Connect with me on LinkedIn:
Feel free to connect with me on LinkedIn to stay updated on the latest trends in #backend development, #Linux, and #scripting. Let's build a stronger network together!

Terminal Multiplexing with TMux in Linux

vinayak — Sun, 03 Dec 2023 19:16:44 +0000

As Linux users, most of our time is spent working in the terminal window, and it's no surprise that we often require multiple terminals for multitasking. Thus the invention of multiplexers. Which significantly enhanced the functionality of the terminal, leading to increased productivity.

There are multiple terminal multiplexers but one of the most popular is TMux. In this article, we will deep dive into TMux's key features.

TMux is a command-line utility for Unix-like operating systems, including Linux. It enables users to create and manage multiple terminal sessions within a single window. In simple words, it's an alternative to using the graphical tabs and lets you organize your terminal into panes and windows.

Installing TMux in Linux

we can install tmux with our package manager (in the terminal)

Debian/Ubuntu:

  sudo apt-get install tmux

Redhat

sudo yum install tmux

Fedora

sudo dnf -y install tmux

Starting Tmux inside Terminal

After installing tmux, you can simply start it by typing the command tmux in your terminal. This initiates a new tmux session.

tmux

Panes in Tmux

Similar to Vim, tmux also has a leader key that is used to trigger various commands within tmux., by default its ctrl + b

To split the window vertically, we can use ctrl + b %
To split the window horizontally, we can use ctrl + b "
Similarly to closing a window, we can use Ctrl + b x, and to Navigate between the panes we can use Ctrl + b <arrow-key>
For changing the panel layout leader key with space can be used Ctrl + b space
To resize a panel in tmux, we can use the resize-pane command. Press the leader key to enter command mode. Similar to Vim, we can then enter the resize command to adjust the size of the pane using the : symbol.

Ctrl + b : resize-pane -L 10
Ctrl + b : resize-pane -R 10
Ctrl + b : resize-pane -D 10
Ctrl + b : resize-pane -U 10

Windows in Tmux

windows in tmux is a little different from Panes, while panes divide the terminal, on the other hand, windows can be used as a new tab. Where each window can contain one or more panes.

To create a new window, press the leader key and c that is ctrl + b c
To Navigate to the next window, Ctrl + b n can be used
To Navigate to the previous window, ctrl + b p can be used
& is used to close a window, ctrl + b &

Renaming windows

Now that we have multiple windows within our terminal emulator, it's a good idea to rename it to streamline our workflow. For Renaming we can use , with ctrl + b

List Windows

We can see a list of windows by using Ctrl-b followed by w. This provides a visual overview, where we can navigate to a window using the arrow keys.

Sessions in Tmux

Sessions in Tmux provide an easy way to group tasks or activities in a single terminal multiplexer in one or more instances.

Creating a Session

As soon as we open tmux in the terminal, a default session is created. However, we can also create a new session with a different name.

For naming a session, we can use the new-session command.

tmux new-session -s session_name

Detaching from a Session

One session is created, and once inside, we can detach it using the combination of d after the leader key. ctrl + b d

Attaching to a Session

After detaching, we can log back in by attaching it using the attach-session command.

tmux attach-session -t session_name

What Defines a Software Developer? Navigating Beyond Technical Expertise

vinayak — Sat, 04 Nov 2023 21:49:15 +0000

Defining any profession is a complex task, and the domain of software development is no exception. It requires not only a technical sense but also a deep understanding of the complexity of the software industry. In this article, we dive deep into the multiple aspects of a software developer as a person, exploring the qualities that go beyond technical skills.

This exploration is based on my two-year journey in the field. While I share my observations, it's important to note that the software development landscape is vast and constantly evolving. Thus, this perspective is open to discussion, correction, and even disagreement, as the beauty of this profession lies in its various approaches and interpretations.

Beyond Technical Skills

Evolving as a developer is a transformative journey that encompasses more than just mastering programming languages and frameworks. It's a unique set of qualities and skills that define a software developer's superiority.

Here are some key aspects I've observed during my experience:

1. Curiosity

Curiosity is a fundamental trait that as humans we possess, but for a software developer, it takes on an entirely different dimension. It’s not just about being curious; it’s about diving deep into the details of your work. For instance, when you’re engrossed in a project, curiosity should drive you to question every aspect of it.

Begin by questioning the purpose of a feature: Why do we need it? What impact will it have on the other features? Question the tools you're using: Why this particular tool? Or why opt for a 'for' loop instead of 'forEach'? Can this complex piece of code be simplified without compromising functionality? Understanding the reasons behind every decision, and every line of code.

Maintaining this level of curiosity isn't easy; it demands relentless questioning and a genuine hunger for understanding. Yet, it is this hunger that fuels your growth as a developer and promotes the developer to explore, experiment, and innovate, pushing the boundaries of your knowledge and expertise. Embracing this unquenchable curiosity transforms a good developer into an exceptional one.

2. Effective Communication

Albert Einstein's timeless wisdom, "If you can't explain it simply, you don't understand it well enough" resonates profoundly with software development. Developers need to communicate complex technical concepts in a clear, understandable manner. Whether collaborating with team members, explaining ideas to clients, or documenting projects, communication skills are essential.

Consider this scenario: your client might lack the technical know-how of the product, while your junior colleague might be well-versed in technical complexities but lacks a broader understanding of its functionality. Bridging this gap demands a subtle approach to communication. It's about simplifying complex jargon into understandable terms, ensuring that both the client and your team comprehensively grasp the information being conveyed.

One of my seniors once remarked that he sometimes feels like he doesn't work in an IT company but in a call center. This observation reflects the communication-heavy nature of our work. Most of our tasks involve discussions over calls, whether it's trying to understand a feature or explaining the same concept to others. Despite the challenges, effective communication remains the backbone of our collaborative efforts.

3. Teamwork and Collaboration

Software development rarely happens in isolation. Developers work within teams, collaborating with diverse professionals such as designers, testers, and project managers. The ability to collaborate effectively, respect differing opinions, and contribute positively to a team dynamic is crucial for project success.

Effective collaboration extends beyond mere coexistence or routine morning status calls. It manifests in the willingness to support one another, promoting an environment where team members assist with understanding features, solving complex lines of code, or seamlessly stepping in when a colleague needs assistance. This collaborative spirit isn't merely about shared tasks; it's about building a collective knowledge base, elevating each other's skills, and strengthening the team's cohesion.

4. Continuous Learning and Humility

In the tech world, learning is vital because things are always changing fast. Even though it can be frustrating how often new technologies come up (as humorously shown on dayssincelastjavascriptframework), it's a reality for developers. This means developers must continuously learn to keep up with market trends.

It's important to stay humble and recognize that there's always room to learn, even for experienced professionals. Valuable insights can come from both newcomers and junior developers.

Implementing a culture of continuous learning might seem straightforward in smaller or flat organizational structures. However, in larger multinational corporations, it can sometimes be overlooked but these corporations are trying hard to create an open and transparent environment that encourages learning.

So, always be open to learning new things and stay humble. It’s not just about surviving; it's about thriving in the ever-changing tech world.

Conclusion

I am not sure about the purpose of the article, but I believe that along with technical proficiency, software developers must develop other important qualities as well. These qualities can help to transform a good developer into an exceptional one. As the software development industry continues to evolve, the traits that define a truly outstanding software developer may also change. In my opinion, these several qualities can contribute to a developer's excellence.

GIT For Beginners

vinayak — Sun, 06 Aug 2023 18:43:22 +0000

Git is a distributed version control system (VCS) that allows developers to track changes in their code, collaborate with others, and manage software development projects efficiently. Developed by Linus Torvalds in 2005, Git has become one of the most popular Version Control System VCS tools in the software development community due to its flexibility, speed, and powerful branching capabilities.

Before diving into the details of how to use Git, it's essential to understand some fundamental concepts:

Repository (Repo): A repository is a directory where your project and its version history are stored. It contains all the files and directories relevant to your project, along with the history of changes.
Commit : A commit is a snapshot of the changes made to your repository's files at a specific time. Each commit has a unique identifier (SHA-1 hash) and includes information such as the author, date, and commit message.
Branch : A branch is a separate line of development in a repository. It allows you to work on new features or bug fixes independently from the main codebase. Branches enable parallel development and prevent conflicts between different features.
Master/Main Branch : The main branch in a Git repository is usually called "master" or "main." It represents the stable version of your project and should ideally contain only production-ready code.
Remote : A remote is a copy of a repository stored on a different server or location. It enables collaboration between multiple developers by allowing them to push and pull changes from a shared codebase.
Clone : Cloning creates a local copy of a remote repository on your machine. It allows you to work on the project locally and sync changes with the remote repository when necessary.
Pull : Pulling is fetching and integrating changes from a remote repository into your local branch.
Push : Pushing is the process of sending your local commits to a remote repository, and updating it with your latest changes.
Merge : Merging combines two or more branches' histories, incorporating the changes from one branch into another.
Pull Request (PR): A pull request is a request to merge changes from one branch (typically a feature branch) into another (often the main branch). It is commonly used in collaborative development to review and discuss code changes before merging.

Basic Git Commands

C reating commands

Initializing a Repository :

git init

This command initializes a new Git repository in the current directory, creating a hidden .git folder to store version control information.

Cloning a Repository:

git clone <repository_url>

This command clones an existing remote repository (github/gitlab) to your local machine, creating a new directory with the repository's contents.

Tracking files

Adding Changes to the Staging Area:

git add <file(s)>

This command stages specific files or all changes in the working directory, preparing them for the next commit.

Committing Changes:

git commit -m "Your commit message here"

This command creates a new commit with the changes that have been staged in the previous step. The -m flag allows you to add a commit message to describe the changes.

Branching

Creating a New Branch :

git checkout -b <branch_name>

This command creates a new branch with the specified name and switches to that branch.

Switching Branches :

git checkout <branch_name>

This command switches to the specified branch, allowing you to work on that branch.

Merging Branches :

git checkout <target_branch>
git merge <source_branch>

These commands merge the changes from the source branch into the target branch. The checkout command switches to the target branch and the merge command incorporates changes from the source branch into it.

Updating commands

Pulling Changes from Remote Repository:

git pull

This command fetches and merges change from the remote repository into the currently checked-out branch.

Pushing Changes to Remote Repository:

git push

This command sends the committed changes from your local repository to the remote repository.

Viewing commands

Checking Repository Status :

git status

This command displays the current status of the repository, showing which files have been modified, staged, or are untracked.

Viewing Commit History :

git log

This command displays a log of all commits in reverse chronological order, showing commit information like author, date, and commit message.

Boost Your JavaScript Skills with These 5 Must-Know Shorthands and Tricks

vinayak — Sat, 01 Jul 2023 20:00:08 +0000

5 powerful shorthands and tricks that will help you write cleaner and more concise code. From ternary operators to template literals, learn how to simplify conditional statements, handle default values, and streamline object manipulation.

These tricks are game-changers for any JavaScript developer. Don't miss this opportunity to enhance your coding skills and take your projects to the next level.

Nullish Coalescing Operator (??)

The nullish coalescing operator allows us to provide a default value for null or undefined variables.

Nullish Coalescing Operator (??) VS Logical OR Operator (||)

The logical OR (||) operator consider falsy values, while the nullish coalescing operator check for null and undefined values.

a || b evaluates to a ? a : b
a ?? b evaluates to a != null/undefine ? a : b

Optional Chaining Operator (?.)

The optional chaining operator provides a way to access nested properties or call methods on an object without worrying about potential null or undefined values. If any intermediate property is null or undefined, the expression short-circuits and returns undefined

Function Property Shorthand

When defining a method inside an object, we can use the shorthand notation to assign a function to a property without using the function keyword.

Logical Assignment Operators (`&&=`, `||=`, `??=`)

JavaScript introduced logical assignment operators in ECMAScript 2021. They allow us to combine logical operations with assignments in a more concise way.

Comma Operator

The comma operator allows us to evaluate multiple expressions and return the result of the last expression. It is typically used in situations where multiple expressions need to be evaluated but only one value is expected.

3 Ways to Clone Objects in JavaScript

vinayak — Wed, 28 Jun 2023 20:19:41 +0000

Top Beginner-Friendly Linux Distributions for Easy Start

vinayak — Sat, 24 Jun 2023 17:08:31 +0000

Are you a beginner looking to dive into the world of Linux? Discover the best Linux distributions tailored for newcomers in this informative video. From intuitive user interfaces to comprehensive documentation and community support, these Linux distributions are perfect for those starting their Linux journey. Join us as we explore the most beginner-friendly options, highlighting their features and benefits to help you choose the perfect Linux distribution for your needs. Get ready to embark on an exciting open-source adventure with the best Linux distributions for beginners!

Docker Cheatsheet

vinayak — Mon, 19 Jun 2023 05:30:48 +0000

Enhance your #docker skills this handy reference #guide covers all the essential #commands, from common operations to advanced #techniques. #Follow along and stay up-to-date with the latest tech #news and best #practices, ensuring you have the knowledge to leverage Docker effectively in your #projects.

Forem: vinayak

The Bcrypt Algorithm for Secure Password Hashing

Bcrypt Algorithm

How Bcrypt Works

Python Implementation of Bcrypt Algorithm

Required Dependencies

Class Initialization

Generating a Salt

Hashing a Password

Code:

Output:

Getting started with RabbitMq using NodeJs

Installing RabbitMq

Setting up RabbitMq with NodeJs

Conclusion

Redis Pipelining in NodeJS

MULTI Command In Redis

Syntax

Using Redis Multi and Pipeline in NodeJS

Install

Multi with node-redis

Redis example of multi

Pipeline with node-redis

Auto-Pipelining example in Node Redis

Output

Example using execAsPipeline method

output

Date Function in Javascript

Optimizing Your Development Workflow with Bash Scripts!

Open Git Repository:

Kill Process by Port:

Backup Script:

Disk Space Checker:

File Cleanup Script:

Find and Replace in Files:

Terminal Multiplexing with TMux in Linux

Installing TMux in Linux

Starting Tmux inside Terminal

Panes in Tmux

Windows in Tmux

Renaming windows

List Windows

Sessions in Tmux

Creating a Session

Detaching from a Session

Attaching to a Session

What Defines a Software Developer? Navigating Beyond Technical Expertise

Beyond Technical Skills

1. Curiosity

2. Effective Communication

3. Teamwork and Collaboration

4. Continuous Learning and Humility

Conclusion

GIT For Beginners

Before diving into the details of how to use Git, it's essential to understand some fundamental concepts:

Basic Git Commands

C reating commands

Tracking files

Branching

Updating commands

Viewing commands

Boost Your JavaScript Skills with These 5 Must-Know Shorthands and Tricks

Nullish Coalescing Operator (??)

Optional Chaining Operator (?.)

Function Property Shorthand

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

Comma Operator

3 Ways to Clone Objects in JavaScript

Top Beginner-Friendly Linux Distributions for Easy Start

Docker Cheatsheet

Logical Assignment Operators (`&&=`, `||=`, `??=`)