Forem: Shivam

Learn CI/CD Pipelines with GitHub Actions 🤗

Shivam — Sat, 15 Apr 2023 15:31:42 +0000

Software Development has evolved a lot, and Continuous Integration and Continuous Deployment (CI/CD) play a significant role in it. When we talk about CI/CD, there are two primary tools that we talk about. First is GitHub Actions and second is Jenkins.

In this blog, I will be taking you through the following things:

Understanding CI/CD.
How GitHub Actions work.

Understanding CI/CD

CI/CD is Continuous Integration and Continuous Deployment. To understand these terms let’s look at the following workflow diagram:

This is the bird's eye view of the CI/CD pipeline. Developer writes some code and pushes it to the remote repository, which is in most cases handled by GitHub. From GitHub, application code goes through the build and test processes in some remote machines. Build and Test processes comes in a continuous integration phase. In the continuous deployment phase build and test code in used to create docker images, which can later be used to create containers, which are used for Kubernetes Cluster.

How GitHub Actions is used for CI/CD

GitHub Actions is a tool that does certain actions on the occurrence of a particular kind of event. An event can be a push to the repository, an issue raised, a pull request, a first contribution, etc. Any event that can be recognized by GitHub can be used to trigger some action. To see all possible events check out GitHub Action events.

We tell GitHub Action what to do and when to use YAML files. Inside the YAML file, we write workflow. Simply a workflow is a collection of job definitions that will be executed concurrently as well as sequentially. A job consists of several steps which will be executed sequentially. By default, jobs run in parallel, but we can specify the dependence of one job on another, then the dependent job will start only when the job on which it depends on finishes its work.

To better understand the workflow look at the diagram below:

Location to store YAML file in GitHub

All the YAML files related to GitHub workflow

How to write workflow in the YAML file

Comments:

You can write comments by starting the line with a ‘#’.

name:

We can start by giving workflow a name using the ‘name’ keyword, although it is not must to have it. If you do not provide a name to the workflow it will take the name as the name of the YAML file.

on:

Using the ‘on’ keyword we can specify the type of actions on which certain task has to be performed. We can only specify this only at one place in the code, i.e. you cannot have two ‘on’ in the file.

Ways of writing content inside ‘on’ section:

on: push

on: [push, pull_request]

# events on which actions should be triggered
on:
  push:
    branches: [ "main" ]

Check out more ways of writing this here.

Generally, it comes just after the name in the workflow file.

env:

Inside the env section, you can specify some key-value pairs, which can be used later inside the file. For a value, you cannot use a key inside the env section.

Example:

env: 
    ARTIFACT_NAME: Shivam

When there is more than one environment variable with the same name, GitHub uses the more specific one. We will see how this works in the later example.

jobs:

We can write one or more jobs inside the workflow file. By default, jobs run in parallel, but we can also set some dependencies between the jobs, so that if one job is dependent on another then it will only start executing when the job on which it depends finishes its work.

Way of writing jobs:

jobs:
    job1:   # identifier
        name: Job1
    job2:
        name: Job2
    job3:
        name: Job3
        needs: [job2]

In the script above, we have specified three jobs with identifiers and names. We must have an identifier for the job but the name is not always required. In job3, it is mentioned that it depends upon the job2, which means it will start executing only when the job2 finishes its work.

Inside the job, we mention a few other things like runs-on and steps. Runs on tell the workflow on which virtual machine this job has to be performed and the steps inside the jobs section tell the steps with which the job will be performed.

steps:

A job contains a sequence of tasks called steps. Steps can run commands, run setup tasks, or run an action in your repository, a public repository, or an action published in a Docker registry.

‘uses’ and ‘run’ are used under jobs to tell the command or action to be performed.

We can also use ‘env’ under jobs.

steps:
      - name: Print a greeting
        env:
          MY_VAR: Hi there! My name is
          FIRST_NAME: Shivam
          MIDDLE_NAME: Kumar
          LAST_NAME: Pandey
        run: |
          echo $MY_VAR $FIRST_NAME $MIDDLE_NAME $LAST_NAME.

From what we have learned till now let us see how we can write files for continuous integration.

Continuous Integration with GitHub Action

Let’s have a look at the following YAML file. I have taken the example given below from GitHub page itself.

name: GitHub Actions Demo
run-name: ${{ github.actor }} is testing out GitHub Actions 🚀
on: [push]
jobs:
Explore-GitHub-Actions:
runs-on: ubuntu-latest
steps:
- run: echo "🎉 The job was automatically triggered by a ${{ github.event_name }} event."
- run: echo "🐧 This job is now running on a ${{ runner.os }} server hosted by GitHub!"
- run: echo "🔎 The name of your branch is ${{ github.ref }} and your repository is ${{ github.repository }}."
- name: Check out repository code
uses: actions/checkout@v3
- run: echo "💡 The ${{ github.repository }} repository has been cloned to the runner."
- run: echo "🖥️ The workflow is now ready to test your code on the runner."
- name: List files in the repository
run: |
ls ${{ github.workspace }}
- run: echo "🍏 This job's status is ${{ job.status }}."

Let's look at all the keywords of the above GitHub action file. Starting with

name using the name we are giving the name to this GitHub workflow as GitHub Actions Demo.

run-name using the run-name we give the workflow runs a name.

on using the on, we tell the workflow when to trigger some action.

jobs using the jobs, we tell the workflow that whatever is under the jobs keyword will be used to specify how and where the job is going to take place.

runs-on using the runs-on, we tell the workflow what kind of virtual machine should be used.

steps is containing the sequence of commands that should be run.

run is used to specify a single command to run on the virtual machine.

uses is used to specify the location and version of a reusable workflow file to run as a job.

I hope this will help to kickstart your GitHub action learning.

To dive deep into GitHub action check out their docs.

Support it by giving it a like 😊.

Starting to learn DevOps

Shivam — Sun, 05 Mar 2023 18:40:23 +0000

Hey everyone,

I am starting a 60-day challenge to learn DevOps technologies.

This might look like a very short time for many people, but I think this is going to work for me because I already know a lot of technologies and concepts that DevOps require.

Things that I already know:

Computer Networking.
Linux
Git and GitHub
Basic knowledge of docker and Kubernetes.

I will be following this roadmap: https://roadmap.sh/devops

After every 5 days, I will be writing what I learned. So if you are also thinking of starting to learn DevOps, LETS GOO!! 💪

Timeline:

Linux Commands easier than ever before 💪

Shivam — Thu, 22 Dec 2022 18:21:02 +0000

The Linux command is a utility of the Linux operating system. When operating Linux, you need to use a shell – a program that gives you access to the operating system’s services. Most Linux distributions use a graphical user interface (GUI), making them beginner-friendly.

However, we recommend utilizing the command-line interface (CLI) because it’s quicker and offers more control. Tasks that require multiple steps on the GUI can be done in a matter of seconds by entering commands into the CLI

In this blog, you will learn all the commands that you should know to get comfortable with the terminal.

To start let’s first understand some basic terms:

Command Line Interface ( CLI ): A CLI is a text-based user interface to run programs.
Shell: A shell is a piece of software that interprets typed commands and runs them.
Terminal: A terminal is software that a shell program runs inside of.

What are commands?

Commands are programs that are available on a system. When we run a command, the system takes some specific action. Most of the commands have a short name.

General command syntax:

command        option(s)      argument(s)

We don’t always need to have options and arguments.

The option tells the command how to operate.

ex:

ls -l

ls -a -l

ls -alh

Here -l is an option. We can have the option of single characters starting with a dash(-), and multiple single-character options can be written together as shown above in the third command. Options with more than one alphabets start with two dashes(—) and those options cannot be written along with other options.

You can use —help option to know details about some commands.

The argument is where we tell the command what to operate on.

ex:

ls -l ./Documents

Here ./Documents is an argument.

File system in Linux:

The above image shows what the file system looks like in Linux.

/home is the directory where normal user store files.

There are two ways to specify a path:

Absolute path: An absolute path is defined as specifying the location of a file or directory from the root directory(/).
Relative path: Relative path is defined as a path relative to the present working directory (pwd).

In the above image shivam is the username, ASUS is the hostname and ~/Desktop is the present working directory.

It is good to know the following directory to get a better understanding of how the commands are working.

Root user’s home directory: /root
User’s home directory: /home
Common configuration files reside in: /etc
Common programs and commands in: /bin, /sbin
Shared libraries and modules: /lib
Shared location for mounting other file systems: /mnt, /media
Kernel and system information: /dev, /proc, and /sys.

Some useful keyboard shortcuts:

Up and Down arrow keys: Using the up arrow key you can get previously written commands.
Tab: It comes very handy while writing arguments in a command if there is some directory with a long name then you can press the tab after writing some of the starting portions of the command if that portion uniquely matches with some directory then the tab will autocomplete it for you.
Tab-Tab: In case you remember only some initial characters of a command, then pressing the tab twice will give a list of commands starting with those characters.
Ctrl-A: Move to the beginning of the line.
Ctrl-E: Move to the end of the line.
Ctrl-Shift-C: Copy text to the clipboard.
Ctrl-Shift-V: Paste text from the clipboard.

Let’s start to look into commands now:

COMMANDS:

man: This command is used to open the manual of any other command.

ex: on typing command man ls.

apropos: This command will help you to find the command you want to use. Let’s say you wanted to list everything present in the current directory, but you don’t remember the ls command for it, then using the apropos list you will get all the commands related to listing things.

pwd: This command is used to know the present working directory.

cd: Changes the shell working directory.

To move into the folder which has space in its name.

For example: Let’s say our current working directory is ~/Desktop and there is a folder with the name “folder name”, then in order to change the working directory to ~/Desktop/folder name/, we will need to use the command like this: cd folder\ name. Here \ is used to ignore the space between the words.

ls: Lists directory contents. We can use various useful options with the ls command.

ls -l: Here -l will tell the ls command to use the long listing format.
ls -a: Here -a will tell the ls command to show all the files including hidden, files that start with ‘.’ are hidden files.
ls -R: Here -R will tell ls to show all the files recursively i.e. everything that is present in the directory will be printed in the output. If there is a folder inside the current working directory and it has some files inside it, then even those files will be printed as output in this case.

stat: Displays the status of a file.

mkdir: This will help to create directories

Here we can see all the files present in the current working directory were listed. Then we wrote the command mkdir newFolderwhich created a new folder in the working directory, which we can see using the ls command.

rmdir: This will help to delete a directory. Writing a command followed by the path name of the directory will delete the directory, but it will work only when the directory is empty.

In the above image, we can see that when the directory is not empty we cannot delete it.

Here we can see that we deleted everything from the newFolder folder, then we are able to delete it using the rmdir command.

cp: This command is used to copy files and folders from one location to other.

In the above image, we can see that we copied the abc.txt file from the Desktop to the newFolder folder present on the desktop.

mv: This command can be used to move files between different directories. This command can also be used to move files to different directories with different names, which we can also use to rename files.

In the above image, we can see that Desktop has a file with the name abc.txt and newFolder folder doesn’t have anything inside it. Then by using the command mv abc.txt xyz.txt, we are renaming abc.txt to xyz.txt, then by using the command mv xyz.txt newFolder/mno.txt, xyz.txt is moved to newFolder folder.

rm: This command can be used to delete files from directories, we can also use it to delete non-empty directories using the -r option, which could not be done by rmdir command.

In the above image, we can see that abc.txt was present in the Desktop directory but after using the command rm abc.txt, it is not there anymore. Similarly, we can see newFolder folder in the Desktop directory with mno.txt file inside it, using the command rm -r newFolder folder newFolder is not there anymore.

find: This command can be used to search files or folders using options as filters. You can explore this command using man.

In the above image, using -name option we are able to find files after applying some filter to the search.

Multi-user Environment

Before moving forward let’s understand the multi-user environment in Linux. In a multi-user environment, the system allows keeping the user’s files separate from other users’ profiles.

whoami: In order to check which user is currently logged in, we can use whoami command.

su: This command can be used to substitute the user. One of the uses of switching users is to do system administration tasks.

There are generally two kinds of users, Normal users, and Superusers.

Super Privileges

The root is often disabled on the modern Linux system.
Admin can borrow the root’s privilege using the sudo command.
sudo: Root privileges can be borrowed using sudo command followed by a password verification.

In the above image, we can see that using ls without sudo to see the root folder’s file is not allowed. But on using sudo command followed by the password we can use it.

To switch to a root user, we can use the -s option after sudo, and to go back to the normal user, you can use the exit command.

File Permissions

For every file, there are permissions details for three types of users:

user (owner of the file)
group (collection of users for whom we can define specific actions)
others (all other users)

When we write command stat with some file name then we get the details of access related to that file.

In the above image, we can see the Access details: (0664/-rw-rw-r—).

For -rw-rwr—, first - is to tell that it is a file then the next three characters belong to the user, the next three to the group, and the last three to others.

There are two methods to represent permission:

Octet (like 755, 644, and 777)
Symbolic (like r—, rw-, —x)

In the symbolic representation, ‘r’ means read, ‘w’ means write, and ‘x’ means to execute.

If a user has permission rwx, that means he can read, write and execute the file.

In octet way of writing permission:

Changing File Permissions

chmod: This command can be used to change the permission of different users.

In the above image, we can use that, the first user in one.txt had permission to read and write only, but after using the command chmod u+x one.txt it also gets permission to execute.

chown: This command can be used to change the file’s owner. This command needs root permission to run.

In the above image, we can see on writing the command ls -l all the details of file one.txt got outputted and there we can see two shivam written, first shivam is in the place of the user and the second shivam is in the place of the group. On writing the command chown without sudo, we are getting operation not permitted, therefore we are using sudo with chown command, which is changing the user from shivam to root.

Links

Links are files that reference other files. It is used to avoid having duplicate files. A link establishes a pointer in one place to a destination in another place.

There are two types of links:

Soft Link: A soft link or symbolic link points to another file.
Hard Link: A hard link points to specific data on the disk.

ln: This command is used to create a new link for some file. We can use -s option with ln for soft links followed by the file we want to point to and then the pointer name

If we would not pass any option with the command then the link will be a hard link.

One thing to note with the soft link is that if we change the location of the file to which the pointer points to then the pointer would not give the correct output or even if the location of the pointer file gets changed, in that case also it would not work.

Commands to read text

cat: This command displays the contents of one or more files without having to open the file for editing.

head: This command will output the first 10 lines of the file you give as an argument. But we can also pass the option to get as many lines as you want using the -n option.

tail: This command is similar to the head command but the only difference is that it will print the last lines.

less: This command displays the text of one page or screenful at a time and provides navigation control.

If you have any suggestions, please write them in the comment section. I would love to add it to the blog. ✌️

How Can I Do Reverse Email Lookup? - 3 Simple Methods

Shivam — Wed, 14 Dec 2022 06:38:50 +0000

A look at the evolution of the data landscape, how technology is helping businesses solve for now, and how the data analysis possible today can provide us with a new understanding of how we, as a society, can perform better in the future.

The most dramatic outcome of the digital revolution is the amount of data that is now collected and analyzed.

In this article, we’ll talk about how you can obtain more data from an email address and the different kinds of data you can get from it. Example of data from an email includes getting contact information about a person or company to verify their authenticity, or collating emails to generate leads for marketing purposes and so on.

To start with let’s look at. What is a Reverse Email Lookup?

What is a Reverse Email Lookup?

A reverse email lookup is basically a data enrichment process used to uncover more information relating to an email address. It's used to harvest actionable data about a person or entity that can be found online.

Examples of information you can get from an email address include:

Finding the owner of the email address
The country they are based in
Job information and social media accounts associated with the email
Phone number, physical address, profile pictures and many more

This can help users figure out who might be contacting them via email and for what purpose, especially if it’s an unknown or suspicious email address.

You can also use it to learn more about the candidates you are hiring or leads (for sales and marketing specialists) you want to convert.

What Is Reverse Email Search Used For?

Considering the type of information you can obtain from performing a reverse email lookup, the only limit to what you can use it for is your imagination. In this section, I'll break down the different use cases where you may require data and information about an individual or entity using their personal or work emails.

1. Scams & Fraud Prevention

Reverse email lookup can be used in order to verify the identity of the email sender, whether or not they are legitimate or if they are scammers. And in today's world where there is a proliferation of scams, it's worth worrying about your own security. But luckily, you can use a reverse email lookup to verify the identity of the emails, to further protect yourself from theft and risks.

2. Know More About A Potential Date

For a more relatable practical day-to-day usage, you can do an email search to find out more about a potential date, learn about their interests and what type of personality they have on social media before actually going on one. ‘Armed’ with enough information, you can quickly determine if it's a date worth going, or you might even identify your one true love even before the date, who knows?

3. Verification of Ecommerce Transactions

Finally, one important use case is to check and verify an online buyer or seller especially when e-commerce shopping is so prominent today. With a simple reverse email lookup, you can mitigate your chances of running into scams and also, be protected from transactors with bad track records.

Reverse Lookup of Work & Professional Emails

Another valuable use case where a reverse lookup can be beneficial is verifying work and professional emails. In the same way that personal emails can tell you a lot about a person, a professional's email contains valuable details about their past and present jobs, skills and capabilities, location and more. These details can be used to determine if the person is a good fit for a particular job.

Many industries benefit from this process of background scrutiny and depend on it heavily in order to find professionals in their field through reverse email searches. Some other scenarios where a reverse email lookup can be applied include:

1. HR Talent Identification

Hiring HR recruitment firms gathering all the information available on the candidates and filter them accurately to fast-track the hiring process. Using a simple email search, they can also retrieve relevant information that is not disclosed by the candidates.

2. Lead Generation

Another great use case is in sales and lead generation. Using a reverse email lookup, sales team can qualify leads accurately, thus cutting down time wasted to work on leads and instead, focus on getting sales quicker and more efficiently.

3. Credit Risks Analysis

Financial firms, especially those that extend credit and loans to their customers, can identify the risk level of a prospective customer before dealing with them based on the data that they are able to obtain from a reverse email lookup.

How Can I Do Reverse Email Lookup? -3 Simple Methods

Let's look at the different ways in which you can perform a reverse email lookup now that you understand what it is and what it involves. There are three main ways to be covered here, ranging from free to paid to a highly-efficient, automated method. Since all three methods are available for use by anyone, it's entirely up to you to pick which one suits your use case the best.

1. FREE Reverse Email Lookup (Google & LinkedIn Search)

The most basic and straightforward way to perform a reverse email lookup is to use Google. As you would do a normal Google search, you can do the same with email addresses. All you have to do is simply input your email in the search bar, and it will return search results with information related to that email.

Look what you get on entering your email address in google search bar.

However, this method is very manual and can be time consuming if you happen to be dealing with a large number of email addresses. Most importantly, it's not guaranteed to return an accurate result as an email might not be crawled successfully by Google.

Another great free alternative to Google is LinkedIn. LinkedIn is a de-facto platform to get information about the professional profile of a person. However, you can‚Äôt perform a reverse email lookup directly in LinkedIn. But you can derive the person's name and company through its email prefix and domain, which you can then use to perform the search according to these two queries.

2. Paid Reverse Email Lookup Tools

If you want a more efficient and reliable solution to handle large datasets of email addresses then you may want to consider going for a paid reverse email lookup tool. With paid tools you can quickly gather the data you need which are all scattered online and present them in a manner easy to use. In addition, you can do searches more quickly and accurately, with all the information properly presented in a dashboard or sheet, ready for you to use and act upon.

There are a lot of paid reverse email lookup tools and services available, so it's up to you to choose what works best for you. One great tool is Spokeo. Spokeo lets you make reverse lookups involving name, addresses and phone, thereby allowing you more ways to obtain data and more data points to utilize.

3. Automated Reverse Email Lookup Using An API

If you still want something better, something that can integrate seamlessly with your existing business system or application, you can consider going for a reverse email lookup API. With an API, a reverse email lookup process can practically run on its on within your application. The data obtained from the email search can then be fed back automatically into your application, allowing you to utilize the data points immediately for your business without worrying about the lookup process itself.

Proxycurl is an excellent tool for obtaining and enriching data about people and companies. One of its many services include a Reverse Work Email Lookup API which you can use to programmatically pull data into your applications. They excel in data relating to the professional world, a more valuable type of data widely sought after. Another attractive feature of Proxycurl is its agile, lightweight pricing structure, at a cost of as low as $0.03 per search. No bulky monthly subscription that tie you down every month so you only get to pay as you use (or pay as you go if you'd like).

Conclusion

Now you know all about reverse email lookup, what it is used for, its capabilities and the different tools available out there depending your use case. Will you now choose to integrate it into your current business workflow, or start using it personally to protect yourself against certain risks or fraud?

Give Proxycurl’s Reverse Work Email Lookup API a try today.

Check out Proxycurl for more information.

Proxycurl products Reverse Email Lookup

Understanding Alternative Data and using Proxycurl

Shivam — Fri, 04 Nov 2022 10:36:58 +0000

In recent years, alternative data has been famed in the investment and finance industries. You can’t deny its presence. Companies are using it to speed up their growth as well as to compete in the market. You might be thinking what is alternative data? How is it so important? I am talking about the same in this article.

What is Alternative Data?

Alternative data, as the term suggests, is non-traditional that can provide information on how well a company or asset can perform in the future, such as company filling, broker forecast, and management guidance. This data can be used for pre-trade investment analysis, as well as helping investors monitor the health of a company, industry, or economy.

Many investments already see that alternative data is just as fundamental data for their financial analysis and insights.

Time is money and when trading financial instruments, a fraction of a second is all that stands between profit and catastrophe.

Now you might be curious about how these data help in investment, financial analysis, growing companies, etc. So let’s see how this work.

How alternative data is used?

In order to use alternative data companies uses Artificial Intelligence. Through machine learning, AI uses alternative data to predict various outcomes and patterns that can help investors and companies enormously.

Today investors are using alternative forms of data for new and innovative ways to turn a profit.

Where can we use alternative data?

By now, it must be clear but still let me just list different sector of people who uses it.

Predictive modeling: A big part of being an analyst is to make educated guesses about how a stock’s price or a company’s financial standing will change. Alternative data help them factor in many different variables that could affect this change, such as the supply of goods/materials, consumer demand, and economic trends.
Demand forecasting: Analysts use alternative data to anticipate future increases or decreases in consumer demand for certain products or services.
Investment research and deal sourcing: Analysts from hedge funds, private equity firms, etc, are the ones who manage all the initial investment research which is critical for finding a profitable deal that avoids unnecessary risk. So the more details they have about an investment, and the more accurate those details are, the better their reporting and recommendations will be, and to help with that alternative data comes into the picture.
Competitive advantage: Now is the time for enterprises to get comfortable with alternative data. As digital technologies and automation reshape how information is managed and used, industries are changing much faster than traditional data analytics can keep up. Alternative data along with artificial intelligence helps to curb this issue.

Different types of Alternative Data

There are many types of alternative data sets. Different platforms are collecting data without you even noticing it, this collection of data helps them to grow faster. Let’s look at different types of alternative data:

Geo-location: Geo-location data which can be used to measure consumer foot traffic, Offers the ability to survey consumer panelists.
Social media data: Social media is the treasure house of a lot of interesting alternative data. You can mine social media sites and derive new insights regarding products, brands, and much more. Sentiment analysis based on social media data is no longer a novel idea.
The Internet: What you see on the website of a particular company is not all that is there on the Internet. There’s much more when it comes to web data that you can explore and exploit.
Email receipts data: The world has yet to find a better way to communicate electronically than emails. Studying the email receipts of giant corporations like Amazon and Uber, you can derive a lot of insights regarding sales, marketing, and other business aspects.
Credit card, and debit card data: People have switched over to credit and debit cards for shopping for a long while now. However, there’s a lot of data that is generated every day regarding purchase behavior and trends that you can make use of.
Satellite data: There’s a growing trend to collect data from satellites or even low-level drones. The data collected in this way would be costly and its quality may vary. While you may get access to a lot of raw data, it may not be exactly useful.

Using Proxycurl as an alternative data provider

Proxycurl is a strong data company with a demonstrable capacity for handling unstructured data. Its core strength in data enrichment capabilities of people and companies - offering insights into people profiles, companies profiles, work & personal email addresses and contact, jobs info, and more sets it apart.

Proxycurl offers APIs that are easy to use, it can drive and power the data-driven applications of hedge funds and investment companies, on top of that they are credit-based for as low as $0.01 per profile enrichment and thus does not tie users up with bulky, heavy subscription or contacts like many other. So Proxycurl is the way to go.

Check out Proxycurl ( https://nubela.co/blog/the-ultimate-guide-to-alternative-data-what-is-it-really ) for more information.

Know more about other products of Proxycurl

Git Commands ( to ease your development 🤗 )

Shivam — Thu, 23 Jun 2022 06:52:36 +0000

Git is a prevalent version control system ( VCS ) used by most programmers. In this blog, I am going to share some tips with basic commands to make using git easier.

To start with git, we need to understand how things work locally on the system while using git.

This diagram will help to understand, what actually happens while using git locally. Starting with the working area, the working area is where the files that are not handled by git, it is the place where all the untracked files are kept. Staging area has files that are going to be part of the next commit. The repository contains all the project commits. Using the repository we can have files as it was at some point in time.

Git Commands:

1. Initializing git in your directory

The very first step that you need to do is to initialize the repository.

git init

2. git config

This command helps you to set the username and user email address to be used with your commits respectively.

git config --global user.name "Shivam164"
git config --global user.email "sp...oo6@gmail.com"

3. git status

This command is used to see the state of the working area and staging area.

 git status

3. git add

This command is used to add files to the staging area.

To take all the files that are untracked in the working area to the staging area, we use:

git add .

Here ‘.’ specifies to stage all the untracked files.

To specify files that should be tracked, we can use their file name:

git add abc.txt

In order to stage abc.txt only.

4. git commit

The git commit command captures a snapshot of the project’s staged changes. Generally, we keep a short message with each commit in order to understand that commit in the future as well as for other people to understand.

⇒ It is good to keep commits in the present tense and short ( about 50 characters ).

git commit -m "first commit"

Here ‘-m’ is for the message.
To stage all your changes and commit them in single command we can use:

git commit -am "committing all changes"

There can be cases when you cannot explain your work in few words, even in such a scenario we should not just write a very big message in a single line, because that will be tough to read such messages on GitHub. For such a scenario after staging some file, we don't just directly commit like above. We write:

git commit

When we write git commit without -m. You will see a console text editor known as Vim.

Now you can start writing your commit message here, you just need to press I (INSERT). And even within the long message, you should keep a short line at the start to before the long message, then after a line space, you can write your long message. When you are done writing your message, you can close this vim by first pressing ‘ESC’ and then ‘:wq’ to save and quit.

One of other useful git commit command:

git commit --amend -m "commit message'

This command will merge this commit with the last commit and it will have a new commit message.

5. git log

The git log command displays all of the commits in a repository’s history.

There are many ways to see commit history :

Most basic one: Shows all the commits from end to start, with all the info related to commits.
```
git log
```
It shows commits based on the HEAD.
To see some number of the last commits:
```
git log -5
```
To see the last 5 commits.
To see commit from some commit to some other commit: We use the hash value of those commits.
```
git log af156ff..32509d0
```
To see the stat of the commits:
```
git log --stat
```
This command gives the basic info along with the summary of number of changes made between each commit.
One of the handiest git log commands:
```
git log --all --oneline --graph --decorate
```
⇒ all: to see all the commits

⇒ oneline: to keep all the data of commits within one line.

⇒ graph: to keep commits in graphical form, very useful when working with branches.

⇒ decorate: to make it visually better.

6. git show

The git show command will help to see details of a particular commit.

git show 1c16945

7. git diff

The git diff command is to see the difference between different commits.

git diff 1c16945..9dcff6

To see the difference between commit with hash value 1c16945 and 9dcff6.

We can also use it directly.

git diff

This will display the difference in files of the working area and directory.

We can use - - staged with git diff

git diff --staged

This will display the difference in files of the working area and staging area.

8. git stash

The git stash temporarily shelves (or stashes) changes you’ve made to your working copy so you can work on something else, and then come back and re-apply them later on.

Only the files that are in the staging area can be stashed.


git stash

After using git stash, if we use the command git status we will not see any file in the staging area.

We can also give a message while using git stash so that if we need it later we will be able to recall what we had done with the stashed files.

git stash save "changed title"

To view all the stashed changes:

git stash list

To view some particular stash, let’s say with index 1

git stash show -p stash@{1}

To retrieves stash changes:

To retrieve last stashed change.

git stash pop

To retrieve stash change with particular index

git stash pop stash@{1}

To delete stashed changes:

To delete all

git stash clear

To deleted some specific ones

git stash drop stash@{0}

9. git branch

The git branch command is used to work with branches in git.

Creating new branch:

From the branch where HEAD is currently pointing to:
```
git branch newBranch
```
From a branch where HEAD is not currently pointing to:
```
git branch newBranch fromBranch
```
Creating a new branch and switching to it:
```
git checkout -b newBranch fromBranch
```

Switching to different branch:

git checkout toSwitchBranchName

Comparing different branches:

git diff master..new_feature

Renaming branches:

To change the name of the branch, HEAD is currently pointing to:

git branch -m newBranchName

To change the name of the branch irrespective of HEAD:

git branch -m oldName newName

Deleting branches

git branch -d branch_to_delete

If we are currently on the branch that we are trying to delete, we will get error.

So we have to make sure that we are not on branch we want to delete.
If the branch we want to delete is unmerged and has commits than this command won’t work. Git does this to stop accidental deletion of branches.

So we need to use ‘-D’ instead of ‘-d’

10. git merge

The git merge command lets you take the independent lines of development created by git branch and integrate them into a single branch.

git merge feature/Nav

The above written command will merge feature/Nav branch with current checked out branch.

Some of the good practices while merging branches, you can checkout here

Currently it has commands only related to handling files locally. I will be updating it soon. 👊

Git VS GitHub

Shivam — Tue, 14 Jun 2022 07:20:15 +0000

Git vs GitHub is one of the things that beginners find tough to understand. So in order to understand their differences let's first look at them individually.

What is Git?

Git is a version control system for tracking changes in computer files. It is used to coordinate work among several people on a project and track progress over time. It is used for Source Code Management in software development.

A version control system is a system that records all the changes made to a file or set of files, so a specific version may be called later if needed. This helps in collaboration with all team members.

Advantages of using git:

Git favors both programmer and non-technical users by keeping track of their project files.
It allows multiple users to work together.
Large projects can be handled effectively.

What is GitHub?

GitHub is a Git repository hosting service, which provides a web-based graphical interface.

GitHub helps every team member to work together on the project from anywhere and makes it easy for them to collaborate.

GIT VS GITHUB

Git	GitHub

Installed locally on the system.	Hosted on the cloud.
Git can be used offline and does not need an internet connection for use.	GitHub cannot be used offline and needs an internet connection.
Git can be used without GitHub.	GitHub cannot be used without Git.
Used for version control system and works as source code management in software development.	Used for centralized source code hosting.
Git has no GUI.	GitHub has GUI.
Code changes like commit, merge, etc. are done using commands from the command line.	Everything is done through a web-based interface.
Open source licensed.	Includes free and pay-for-use tiers.

Bit Manipulation

Shivam — Sat, 26 Feb 2022 17:52:29 +0000

Bit Manipulation

Bit manipulation is the process of applying logical operations on a sequence of bits to achieve a required result. Like in decimal format, we do addition, subtraction, multiplication and division. Similarly, we can apply some operation to manipulate bits of numbers.

In Binary notation, we use 1’s and 0’s to represent numbers.

For ex : 5 => 101
14 => 1110

One way of saying that some bit at some position is 1 or 0, we say bit is set or on when it is 1 and not set or off when it is 0.

Those operators are known as bitwise operators.
There are six types of bitwise operators.

& ( AND )
| ( OR )
^ ( XOR )
<< ( LEFT SHIFT )
>> ( RIGHT SHIFT )
~ ( NOT )

We will be covering the first five of these in this blog, these are the ones that are mostly used.

AND &

Bitwise AND &

bit a   |  bit b  | a & b (a AND b)
0           0          0
0           1          0
1           0          0
1           1          1

We can use & operation to calculate the number of set bits in some number.

To understand that, we first need to go through an observation.

Let’s take a number.
For ex : 42 (110100), if we subtract 1 from 42 it will become 41 that is 110011

One thing that we can notice in this is that all the bits that are after the first set bit (from right) in 42 turned to 1 and that itself turned to 0.

Similarly, in all numbers once we decrement it by 1 all the bits that are after the first set bit (from left) will turn into 1 and that itself will turn into 0.

For ex : 10 => 1010 9 => 1001
14 => 1110 13 => 1101

To calculate number of bits in log(n) time :

int count = 0;
while(n>0){
    count++;
    n = n&(n-1);
}

In the above written code, every time n is going inside the loop it is losing one set bit and incrementing the count by 1. And that will be the total numbers of set bit in n.

BITWISE OR ( | )

bit a |  bit b |  a | b (a OR b)
0       0         0
0       1         1
1       0         1
1       1         1

Bitwise OR is also a binary operator that operates on two equal-length bit patterns, similar to bitwise AND. If both bits in the compared position of the bit patterns are 0, the bit in the resulting bit pattern is 0, otherwise 1.

XOR ( ^ )

Bitwise XOR also takes two equal-length bit patterns. If both bits in the compared position of the bit patterns are 0 or 1, the bit in the resulting bit pattern is 0, otherwise 1.

Some properties of xor :

A ^ A = 0
A ^ 0 = A
A ^ ( B ^ C) = ( A ^ B ) ^ C
A ^ B = B ^ A

One of the important things is that, if we are taking xor of many numbers. We can say that the result will have 1 at some position if the count of numbers with 1 at that position is odd, otherwise it will be zero.

Using the above observation. We can say that, if we calculate xor of first n natural numbers, then it will depend upon remainder that we get on n%4.

If it is 0.
Then answer = n.
If it is 1.
Then answer = 1.
If it is 2.
Then answer = n + 1.
If it is 3.
Then answer = 0.

Left Shift (<<)

If we apply left shift to a number with x units ( 5<<x) this means that we are shifting bits of number to the left by x units and all the empty positions on the right will be filled with 0.

Mathematically, on applying left shift to a number by x units it gets multiplied by 2^x.

For ex : 3<<1 = 2X3 = 6 ( 110 ) [ 3( 11 )]
3<<2 = 4X3 = 12 ( 1100)

9<<3 = 8X9 = 72 (1001000) [9( 1001 )]

Right Shift (>>)

This is just opposite of the left shift, on applying it to a number with x units it shifts bits to right by x units.

Mathematically, on applying the right shift to a number by x units it gets divided by 2^x.

For ex : 3>>1 = 3/2 = 1
3>>2 = ¾ = 0

Some nice way to use these bitwise operations :

First of all, we can use these to solve real life problems, but obviously it will depend upon how we can apply bitmask.

Short tricks that we can use daily in our code are as follows :
To calculate some power of 2, we can directly write it as 1<<x which will be equal to 2^x.
We can use & and << together to check whether a bit at some position is on or off.

bool on(int n, int position){
    int PowerOf2 = 1<<position;
    return ((n&PowerOf2)==0)? false : true;
}

Suggestions are welcomed, to make this blog better.

Async and Await

Shivam — Sat, 19 Feb 2022 05:04:41 +0000

Being a web developer you must have seen async and await in codes. And there are times when you forgot how it actually works, this is what happened with me, therefore I am writing this blog to have a quick recap on async and await on times when I need to. And I think there are many people like me who goes through this issue.
So, I got your back. This is beginner friendly as well. So just dive into it.

To understand async and await, we first need to understand promises in javascript.

Promise is just like a promise in real life.

For example : I promise to score good in upcoming test.

There can be two outcome of this promise, either promise will be resolved or it will be rejected. In the example, if I would score good in test, that means promise is resolved. But if I am not able to score good that means promise is rejected.

Promise are good to use when you want to do something that is going to take time in background. For example if you want to fetch an image from server.

Let’s see how we can create a promise using code in javascript.

let willScoreGood1 = new Promise((resolve,reject) ⇒ {

let score = 90

if(score≥90){

resolve(”You completed your promise, congrats”);

}else{

reject(’Failed’);

}

})

willScoreGood1

.then((message) ⇒ {

console.log(message);

}.catch(err ⇒ {

console.log(err);

})

let willScoreGood2 = new Promise((resolve,reject) ⇒ {

let score = 70

if(score≥90){

resolve(”You completed your promise, congrats”);

}else{

reject(’Failed’);

}

})

willScoreGood2

.then((message) ⇒ {

console.log(message);

}.catch(err ⇒ {

console.log(err);

})

In the code we have written two promise, first one willScoreGood1 and second one willScoreGood2 on calling first it will get resolved and corresponding to that we will receive a message in .then. On calling second promise we will get an error, which we will get in .catch.

Atlast we can see that using promises we can get the result of some task or the error for that task.

So now we know how promise works. Therefore we can move on to async and await.

Let’s start with async :

We use async keyword in front of a function to make it asynchronous, i.e. to take it out of normal sync of code.

For example :

// NORMAL FUNCTION
const greetings = () =>{
   console.log("welcome everyone");
} 

// ASYNC FUNCTION 

const greeting = async () => {
   console.log("welcome everyone");
};

greetings();
greeting();

When we write async in front of a function, then it will return values in form of promises.

At most of the times we use async and await together.

So let’s move to await keyword.

The advantage of an async function only becomes apparent when you combine it with the await
keyword. await only works inside async function

await can be put in front of any async promise-based function to pause your code on that line until the promise fulfills, then return the resulting value.

CODE :

function getRandomArbitrary(min, max) {
    return Math.random() * (max - min) + min;
}

async function GreaterThan5(){
    let value = getRandomArbitrary(0,10);
    setTimeout(
        if(value <= 5){
        return 'small';
    else{
        throw new Error('Value is large');
    },3000);
}

const asyncAndAwaitTogether = async () => {
    const result = await GreaterThan5();
    console.log(result);
}

asyncAndAwaitTogether()
    .then(result => {
            console.log(result);
    }.catch(error => console.log(error);)

In the code, we have a function in the beginning that will return a random value in the range between min and max.

Then there is a async function GreaterThan5 and it will take some time to complete, when called, that’s why we have made it async.

After that there is one more async function asyncAndAwaitTogether, in this function we can see how async and await works together.

First thing we can notice in asyncAndAwaitTogether is that it is async, which means it will return a promise and inside the code we are calling GreaterThan5 function and before that we have written await, what await does here is that it stops the code till it gets any response, as soon as it get any result in form of resolve or reject. If the result is resolve then we will move to next line, but if we are getting reject in the result, then we will come out of function.

In the end we are calling asyncAndAwaitTogether, as it will return a promise we are using .then and .catch to get any kind of result.

Conclusion, on using async keyword before a function will make it asynchronous and it will return promises. We use await in async function to stop the code till the result is fetched.

That is all you need to get started with async and await,