Forem: San

What is Git, and Why Should You Use It?

San — Mon, 01 May 2023 15:34:42 +0000

Git is a version control system that allows you to track changes in your software development projects. It's a powerful tool that enables collaboration, makes it easy to revert to previous versions of your code, and facilitates teamwork on different branches of your codebase without interfering with each other's work.

The Benefits of Version Control with Git

One of the most significant advantages of Git is that it supports branching. Branching is the creation of different versions of your codebase. Each branch is a separate copy of your codebase, and changes made in one branch do not affect the others until they are merged back into the main branch.

Git is widely used by developers worldwide, and it's easy to install on Windows.

How to Install Git on Windows in 15 Easy Steps

Visit the Git website and download the latest version of Git for Windows.
Once the download is complete, open the installer by double-clicking on the downloaded file.
In the Git Setup wizard, select the components you want to install. By default, all components are selected, so you can leave them as is.
Choose the installation directory. The default location is usually fine, but you can change it if you want.
Select the default editor that Git should use. You can choose between Nano, Vim, Emacs, and Notepad++.
Choose the terminal emulator that Git should use. The default option is "Use Git Bash only," which is recommended.
Select the default behavior for line endings. The default option is "Checkout as-is, commit as-is," which is usually fine.
Choose the default behavior for handling symbolic links. The default option is "Checkout as-is, commit as symbolic links," which is also usually fine.
Select whether you want Git to be available to all users or just the current user. The default option is "Use Git from Git Bash only," which is recommended.
Choose the default behavior for the PATH environment variable. The default option is "Use Git from the Windows Command Prompt," which is recommended.
Choose the HTTPS transport backend. The default option is "Use the OpenSSL library," which is recommended.
Click "Install" to begin the installation process.
Wait for the installation to complete. This may take a few minutes.
Once the installation is complete, click "Finish" to exit the installer.
Open a command prompt or Git Bash terminal and type "git --version" to verify that Git was installed correctly. If everything worked, you should see the Git version number displayed in the terminal.

Getting Started with Git: Creating a Repository and Making Commits

Once you've installed Git on Windows, it's time to get started with version control. The first step is to create a repository, which is a directory that contains all the files and folders that make up your project.

To create a repository, open a command prompt or Git Bash terminal and navigate to the directory where you want to create the repository. Then, type the following command:

git init

This will create a new Git repository in the current directory. You can now add files to the repository by typing the following command:

git add <filename>

This will stage the file for the next commit. To make a commit, type the following command:

git commit -m "Your commit message here"

This will create a new commit with the changes you made to the file. You can view your commit history by typing the following command:

git log

Branching and Merging with Git: A Beginner's Guide

As mentioned earlier, branching is one of the most significant benefits of using Git. Branches allow you to work on different parts of your codebase without interfering with each other's work. For example, if you're working on a new feature, you can create a separate branch for it, work on the feature, and then merge it back into the main branch when it's ready.

To create a new branch, type the following command:

git branch <branchname>

This will create a new branch with the specified name. You can switch to the new branch by typing the following command:

git checkout <branchname>

Now you can make changes to the codebase in the new branch without affecting the main branch. When you're ready to merge the changes back into the main branch, switch back to the main branch and type the following command:

git merge <branchname>

This will merge the changes from the specified branch into the main branch. If there are any conflicts between the two branches, Git will prompt you to resolve them manually.

Collaborating with Git: Pushing and Pulling Changes to a Remote Repository

Git also enables collaboration between developers by allowing them to push and pull changes to a remote repository. A remote repository is a copy of your codebase stored on a remote server, such as GitHub or Bitbucket.

To push your changes to a remote repository, you first need to add the remote repository as a Git remote. This is done using the following command:

git remote add <name> <remoteurl>

Here, is a nickname for the remote repository, and is the URL of the remote repository.

Once you've added the remote repository, you can push your changes to it using the following command:

git push <name> <branchname>

This will push the changes in the specified branch to the remote repository.

To pull changes from a remote repository, you can use the following command:

git pull <name> <branchname>

This will pull the changes from the specified branch of the remote repository and merge them into your local branch.

Git Tips and Tricks: Customizing Your Workflow and Resolving Conflicts

Git is a versatile tool with many customization options. Here are a few tips and tricks to help you get the most out of Git:

Use Git aliases to create shortcuts for commonly used Git commands.
Use Git hooks to automate tasks, such as running tests or formatting code.
Use Git stash to save changes temporarily without committing them.
Use Git bisect to track down bugs by systematically testing different versions of your codebase.
Use Git rebase to combine multiple commits into a single commit.

Git can also help you resolve conflicts when two or more branches have made conflicting changes to the same codebase. When this happens, Git will prompt you to manually resolve the conflict by editing the affected files and choosing which changes to keep.

Git Resources: Where to Learn More and Get Help

If you're new to Git, there are many resources available to help you learn more about it. Here are a few places to start:

The official Git documentation: https://git-scm.com/doc
The Git tutorial on Atlassian's website: https://www.atlassian.com/git/tutorials
The Pro Git book by Scott Chacon and Ben Straub: https://git-scm.com/book/en/v2

Conclusion: Why Git is Essential for Developers

In conclusion, Git is an essential tool for developers that offers many benefits, including version control, branching and merging, collaboration, and customization options. Whether you're working on a personal project or collaborating with a team, Git can help you keep track of changes to your codebase and ensure that everyone is working on the same version of the code.

Installing Git on Windows is a straightforward process that involves downloading and installing Git for Windows from the official website. Once you've installed Git, you can start using it to manage your codebase and collaborate with others.

If you're new to Git, it may take some time to learn all of its features and how to use them effectively. However, with practice and the help of online resources, you can become proficient in Git and use it to streamline your development workflow and improve your productivity. With Git, you can take your coding skills to the next level and become a more efficient and effective developer!

Exploratory Data Analysis Case Study - Companies Registered in India [1857 - 2020]

San — Tue, 11 Apr 2023 16:28:29 +0000

Exploratory Data Analysis (EDA) is a critical step in any data science project, and it involves analyzing datasets to summarize their main characteristics and uncover patterns, relationships, and anomalies. In this blog post, we'll take a closer look at one such dataset titled "Registered Companies" on Kaggle, and perform EDA on it to understand its main features.

The dataset contains information about registered companies in India, and includes 15 columns with various details such as the company name, registration date, industry classification, authorized capital, paid-up capital, and more. The dataset has over 15,000 records, making it a rich source of information for analyzing trends in the Indian corporate sector.

Let's begin by importing the necessary libraries and loading the dataset into a pandas DataFrame:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

companies_df = pd.read_csv('https://cdn.jovian.ml/sanuann/registered_companies.csv')

Next, let's take a look at the first few rows of the DataFrame to get an idea of the data structure:

companies_df.head()

The output should resemble the following:

             CIN                      COMPANY_NAME  ...    PAIDUP_CAPITAL      ACTIVITY_CODE
0  U93090TN2008PTC069316     BLUE LOTUS TECHNOLOGIES  ...           1500000  93090
1  U14292DL2005PTC136633  INDO ASIAN FUSEGEAR LIMITED  ...          68872420  14292
2  U51103MH2007PTC170327      JAIHIND PROJECTS PR LTD  ...          37830000  51103
3  U45203KA2007PTC042123      SILVERLINE INDIA PR LTD  ...           1600000  45203
4  U51109WB2005PTC106210        RUPASHI BANGLES PR LTD  ...            100000  51109

We can see that the dataset contains the company identification number (CIN), company name, registration date, state, industry classification, authorized capital, paid-up capital, and other details.

Let's now explore the dataset by analyzing the distribution of various features using histograms, box plots, and scatter plots. We'll start by analyzing the distribution of the authorized and paid-up capital:

sns.histplot(companies_df['AUTHORIZED_CAPITAL'])
plt.title('Distribution of Authorized Capital')
plt.xlabel('Authorized Capital (in crores)')
plt.show()

The output should resemble the following:

We can see that the majority of companies have an authorized capital of less than 10 crore, with a few companies having authorized capital greater than 100 crore.

Let's now analyze the relationship between authorized and paid-up capital using a scatter plot:

sns.scatterplot(x='AUTHORIZED_CAPITAL', y='PAIDUP_CAPITAL', data=companies_df)
plt.title('Relationship between Authorized Capital and Paid-up Capital')
plt.xlabel('Authorized Capital (in crores)')
plt.ylabel('Paid-up Capital (in crores)')
plt.show()

The output should resemble the following:

We can see that there is a strong positive correlation between authorized and paid-up capital, indicating that companies with higher authorized capital tend to have higher paid-up capital as well.

Let's now analyze the distribution of the industry classification using a box plot:

sns.boxplot(y='PRINCIPAL_BUSINESS_ACTIVITY_AS_PER_CIN', x='PAIDUP_CAPITAL', data=companies_df)
plt.title('Distribution of Industry Classification by Paid-up Capital')
plt.xlabel('Paid-up Capital (in crores)')
plt.ylabel('Industry Classification')
plt.show()

The output should resemble the following:

We can see that the distribution of industry classification varies widely across different paid-up capital levels, with certain industries such as finance and real estate having higher paid-up capital on average.

In conclusion, we've performed EDA on the "Registered Companies" dataset, and analyzed the distribution of various features using histograms, scatterplots, and box plots. We've identified interesting trends such as the strong correlation between authorized and paid-up capital, and the variation in industry classification across different paid-up capital levels. The dataset provides valuable insights into the Indian corporate sector, and can be used for further analysis and modeling.
For more information on this analysis or to run the project see here: https://jovian.com/sanuann/eda-registered-companies

I hope you found this blog post informative and helpful. If you have any questions or feedback, please feel free to leave a comment below.

How to encrypt a text using Python (key and text) and decrypt that cipher in JavaScript using the same key.

San — Tue, 11 Apr 2023 13:38:41 +0000

Here's an example of how to encrypt a text using Python and decrypt it using JavaScript using the same key.

First, let's write the encryption function in Python:

import base64
from Crypto.Cipher import AES

def encrypt(key, text):
    cipher = AES.new(key.encode(), AES.MODE_ECB)
    text = text.encode()
    while len(text) % 16 != 0:
        text += b' '
    encrypted_text = cipher.encrypt(text)
    return base64.b64encode(encrypted_text).decode()

This function uses the PyCryptodome library to perform AES encryption in ECB mode. It takes in a key and a text to encrypt, and returns the encrypted text in base64-encoded format.

Now, let's write the decryption function in JavaScript:

function decrypt(key, encrypted_text) {
    var decipher = crypto.createDecipheriv('aes-256-ecb', key, '');
    var decrypted_text = decipher.update(encrypted_text, 'base64', 'utf8');
    decrypted_text += decipher.final('utf8');
    return decrypted_text;
}

This function uses the built-in crypto module in Node.js to perform AES decryption in ECB mode. It takes in a key and the encrypted text (in base64-encoded format), and returns the decrypted text.

Note that we need to use the same key and mode of operation (ECB) in both the Python and JavaScript functions.

Here's an example usage:
In python:

key = 'mysecretkey'
text = 'Hello, world!'
encrypted_text = encrypt(key, text)
print(encrypted_text)

In javascript:

var key = 'mysecretkey';
var encrypted_text = 'ryd7yQJ4h8gkSYJxKxHqKA==';
var decrypted_text = decrypt(key, encrypted_text);
console.log(decrypted_text);

This should output Hello, world! in both Python and JavaScript.

Note that ECB mode is generally not considered secure for encryption, as it can leak information about the plaintext. It's better to use a more secure mode like CBC or GCM.

Let us now try the same problem using one of the more secure ways. Here's an example using AES in CBC mode with PKCS7 padding in Python and Node.js:

Python Encryption:

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad

def encrypt(key, text):
    iv = b'\x00' * 16 # initialization vector, must be random for real-world use
    cipher = AES.new(key.encode(), AES.MODE_CBC, iv)
    text = text.encode()
    padded_text = pad(text, AES.block_size, style='pkcs7')
    encrypted_text = cipher.encrypt(padded_text)
    return base64.b64encode(iv + encrypted_text).decode()

JavaScript decryption:

const crypto = require('crypto');

function decrypt(key, encrypted_text) {
    const encrypted_bytes = Buffer.from(encrypted_text, 'base64');
    const iv = encrypted_bytes.slice(0, 16);
    const ciphertext = encrypted_bytes.slice(16);
    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
    decipher.setAutoPadding(false); // disable automatic padding
    const decrypted_text = decipher.update(ciphertext);
    const unpadded_text = Buffer.concat([decrypted_text, decipher.final()]);
    return unpadded_text.toString('utf8');
}

Here, we use AES in CBC mode with a random initialization vector (IV) for each encryption. We also use PKCS7 padding, which is a commonly used padding scheme that ensures that the plaintext is a multiple of the block size before encryption. In addition, we disable automatic padding in the JavaScript decryption function, since we need to handle padding manually.

Here's an example usage:
python version:

key = 'mysecretkey'
text = 'Hello, world!'
encrypted_text = encrypt(key, text)
print(encrypted_text)

JavaScript version:

const key = 'mysecretkey';
const encrypted_text = 'WwOzn2/Cyaa1/Hpnv2PrMhB6g0m6o9PbyiG4z4HiW0w=';
const decrypted_text = decrypt(key, encrypted_text);
console.log(decrypted_text);

This should output Hello, world! in both Python and JavaScript.

Note that the key should always be kept secret and should be shared securely between the encrypting and decrypting parties. In addition, the IV should be random for each encryption to ensure security.

In this article, we demonstrated how to encrypt a text using Python with AES encryption in CBC mode and PKCS7 padding, and how to decrypt the encrypted text using JavaScript with the same key. The Python function used the PyCryptodome library for AES encryption, while the JavaScript function used the built-in crypto module in Node.js.

We also discussed the importance of using a secure encryption mode like CBC and using a random initialization vector (IV) for each encryption to ensure security. Finally, we highlighted that the key should always be kept secret and shared securely between the encrypting and decrypting parties.