Forem: Vishwas Tyagi

Need help with Resume

Vishwas Tyagi — Sat, 01 Oct 2022 18:00:52 +0000

I finished my resume today. I'm not sure how to write a good resume. I need someone to go over it and make valuable suggestions on how I can improve it.

Resume link: https://drive.google.com/file/d/1AExrQvdYU7mGEFb4DVKTBLViAQQlKdHC/view?usp=sharing

RESUME - VISHWAS TYAGI.pdf - Google Drive

drive.google.com

Please feel free to offer your valuable suggestions.

The Practical Guide to Contributing to Open Source Projects

Vishwas Tyagi — Wed, 07 Sep 2022 06:39:32 +0000

Introduction
Using GitHub
- Creating a local git repository
- Creating a repository on GitHub
- Pushing code to the GitHub repository
Contributing to Open Source Projects
- Step 1: Finding the repository to contribute to
- Step 2: Forking the repository
- Step 3: Cloning the fork
- Step 4: Navigating to local repository
- Step 5: Checking the "origin" remote
- Step 6: Adding the "upstream" remote
- Step 7: Pulling the latest changes
- Step 8: Creating a new branch
- Step 9: Making changes
- Step 10: Committing changes
- Step 11: Pushing changes to fork
- Step 12: Creating a pull request
- Step 13: Discussing the pull request
- Step 14: Adding more commits to the existing pull request
- Step 15: Discussing the pull request again
- Step 16: Deleting branch from the fork
- Step 17: Deleting branch from the local repository
- Step 18: Synchronizing the fork with the project repository

Introduction

Mike: Hey VT, you taught me about git over here. Since then, I am having a good time working with git.

I recently heard about the terms GitHub and Open Source Software. I am curious to know about them. Can you tell me something about them?

VT: Yeah, sure.

💡 GitHub is basically a cloud-based website where you can host git repositories and collaborate with other people.

💡 Open Source Software is a type of software that has freely accessible source code and is distributed under a license that allows you to examine, modify, and use the code without restriction.

Mike: Could you please explain how I can use GitHub?

VT: Ok, let's get into it.

Using GitHub

VT: Let's create a git repository and push it onto GitHub.

Mike: Ok, I'm excited.

📌 Make sure you have git installed before moving forward.

Creating a local git repository

1. Initialize a new git repository

VT: First, we have to create a git repository on our computer.

Open a terminal (or command prompt) in an empty folder or a project folder and run the following command:

$ git init

Output:

2. Create a file

VT: We now have a git repository set up. Let's create a new file.

Create a new file (or modify an existing one) in the folder where we set up the git repository.

Let's call our file index.html and add the following code to it:

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>GitHub Guide</title>
  </head>
  <body>
    <h1>Hello GitHub!</h1>
  </body>
</html>

Save the file.

VT: Now, we can run this command to see our changes tracked by git.

$ git status

Output:

3. Commit changes

VT: Let's commit our change.

Run the following commands:

$ git add index.html
$ git commit -m "added index.html"

Output:

Mike: Ok, I have successfully committed my changes. What's next?

VT: Next, the exciting part, we will create a repository on GitHub.

Creating a repository on GitHub

1. Log in to GitHub

VT: First step, log in to GitHub.

📌 If you are new to GitHub, create a new account on GitHub.

📌 For security purposes, GitHub provides a PAT (Personal Access Token) to use in place of a password while pushing code to GitHub. Please generate your PAT as soon as you log in to GitHub for the first time. You can generate your PAT by following this guide.

2. Create a repository on GitHub

VT: Click the + icon in the upper right corner of the GitHub homepage.

Select New repository.

A page will open to create a new repository.

Enter the name and description (optional) for the new repository.

Choose whether to make the repository Public or Private.

Click the Create repository button at the bottom of the page.

VT: We now have a GitHub repository set up. Let's see how we can push our code to the GitHub repository.

Pushing code to the GitHub repository

1. Add remote to the local git repository

Mike: What do you mean by adding remote?

VT: Connecting our local git repository to a remote (online) repository, such as a GitHub repository, is what adding remote means.

It enables us to pull updates and push our changes to the remote repository.

We can add remote to our local git repository by running the following command:

$ git remote add origin URL_OF_GITHUB_REPOSITORY

📌 Make sure to replace URL_OF_GITHUB_REPOSITORY with the URL of your own GitHub repository with .git added at the end.

2. Rename the branch from `master` to `main`

VT: Before we can push our git repository to GitHub, we must rename the branch master to main.

Mike: Why do we have to rename the git branch?

VT: It's because GitHub uses main as its default branch, whereas git uses master.

Run the following command to rename the current branch to main:

$ git branch -M main

3. Push code to GitHub

VT: Now, it's time to push our code to GitHub.

Run the following command:

$ git push -u origin main

When prompted, enter your GitHub username and password.

📌 Use your PAT (Personal Access Token) in place of the password.

Congratulations! We now have a complete GitHub repository.🎉🎉

Contributing to Open Source Projects

Step 1: Finding the repository to contribute to

VT: To contribute to an open-source project, we must first navigate to the project's GitHub repository.

But, for practice, I've set up a GitHub repository called github-playground. You can find it here.

📌 I recommend that you follow this guide and contribute to the GitHub repository (github-playground).

VT: Go to https://github.com/vishwast03/github-playground

Step 2: Forking the repository

Mike: What do you mean by 'forking'?

VT: Here, 'forking' means copying the original repository to our own account.

To Fork the repository, click on the Fork button in the upper-right corner of the repository.

On next page, click Create fork button at the bottom.

Step 3: Cloning the fork

VT: Now, we have to clone the forked repository to our local machine using git.

Cloning means copying a remote repository to our local machine. It is done to be able to work on the project.

To clone:

First click the Code button on the forked project on your GitHub.

Copy the URL from the tab opened.

Run the following command to clone the forked repository.

$ git clone URL_OF_FORK

📌 Make sure to replace URL_OF_FORK of with the URL you have copied in the previous step.

Output:

Step 4: Navigating to local repository

VT: Use the following command to navigate to the local repository:

$ cd NAME_OF_REPOSITORY

Step 5: Checking the "origin" remote

VT: Now, we will check if our fork is added as remote origin or not.

Use the following command to list all the remotes:

$ git remote -v

The output of above command should look like this:

📌 If your fork was not added correctly as origin, you can use the following command to add it manually:

$ git remote add origin URL_OF_FORK

📌 Make sure to replace URL_OF_FORK with the URL of your fork on GitHub.

Step 6: Adding the "upstream" remote

VT: Before we start working on the project, we have to add the original project repository as remote upstream in our local repository.

It enables us to pull updates from the main project.

Use the following command to add remote upstream to our local repository:

$ git remote add upstream URL_OF_PROJECT

📌 Make sure to replace URL_OF_PROJECT with the URL of the original project (not fork).

You can check if the remote was added or not by running the following command:

$ git remote -v

The output should look like this:

Step 7: Pulling the latest changes

VT: It is the best practise to always download the most recent changes from upstream before beginning work on a project.

Run the following command to pull the latest changes from upstream into our local repository:

$ git pull upstream main

Output:

Step 8: Creating a new branch

VT: Let's create a new branch to begin our work.

💡 Always create a new branch before working on the project.

Run the following command:

$ git checkout -b BRANCH_NAME

📌 Make sure to replace BRANCH_NAME with the name you want to give to your branch (e.g. feature).

You can list all your branches by running the following command:

$ git branch

Output:

Step 9: Making changes

VT: It's time to make some change to our project.

If you are working on github-playground project then, open Players.md file in your favourite text editor.

Add the following line to Players.md file:

- [YOUR_NAME](YOUR_PROFILE_URL)

📌 Make sure to replace YOUR_NAME with your real name and YOUR_PROFILE_URL with your profile URL (you can share any profile that you want, e.g. GitHub, Twitter, dev.to, etc.).

📌 If you don't want to share your profile, write your name like this:

- YOUR_NAME

Save the file.

Step 10: Committing changes

VT: Let's now make a commit to the repository.

Run the following command to add the change to staging area and make a commit to the repository:

$ git add .
$ git commit -m "DESCRIPTION_OF_CHANGES"

📌 Make sure to replace DESCRIPTION_OF_CHANGES with the actual description.

Output:

Step 11: Pushing changes to fork

VT: We will now push our changes to our forked repository.

Mike: Why do we have to push the changes to the forked repository? Can't we just push to the original repository?

VT: We can't push the changes directly to the original repository. We don't have access to that repository.

We must first push the changes to the forked repository, then we will make a pull request from there.

Run the following command to push the changes to the forked repository:

$ git push origin BRANCH_NAME

📌 Make sure to replace BRANCH_NAME with the name of the branch you are working with.

When prompted, enter your GitHub username and password.

📌 Use your PAT (Personal Access Token) in place of the password.

Output:

Step 12: Creating a pull request

VT: Now it's time to make a pull request.

Navigate to the forked repository on GitHub.

A prompt to make a pull requset must have appeared.

Click the button labelled Compare & pull request.

On the next page, add the Title and Description to your pull request.

Now, click Create pull request button at the bottom.

We have successfully created a pull request. Cheers!

Mike: Oh! Great! What do we have to do next?

VT: Now we must discuss the pull request with the maintainer of the repository and, if necessary, make additional changes.

Step 13: Discussing the pull request

VT: Now that we've made a pull request, the repository's owner/maintainer will be notified about it.

The maintainers may initiate a discussion about the pull request and, if necessary, suggest changes.

If they are satisfied with the changes we have made, they will either merge the changes back into the original repository or suggest some changes.

If they have suggested any changes, we must implement them and make another commit to the existing pull request.

Step 14: Adding more commits to the existing pull request

VT: If we need to make changes after submitting a pull request, we must go to our local git repository and make the changes there.

To do so, we must switch to the branch on which we were previously working.

Run the following commands to check and switch the branch:

$ git branch
$ git checkout BRANCH_NAME

📌 Make sure to replace BRANCH_NAME with the name of the branch you were working with.

Output:

Now that we've switched to the branch with which we'll be working, we simply need to repeat steps 9 through step 11.

Step 15: Discussing the pull request again

VT: We must now re-discuss the pull request with the repository's maintainers.

If the maintainers approve and merge your changes, you will have made your first contribution to open source. It's time to celebrate.🎉🎉

Mike: Yay!!

Step 16: Deleting branch from the fork

VT: We now need to do some cleanup.

We have to delete the branch from our fork on GitHub.

To do so, we must first navigate to our forked repository page and open the dropdown labeled with the branch name main.

Click View all branches at the bottom of the dropdown menu.

Click the delete button corresponding to the branch with which we were working.

Click Delete from the popup which will appear.

Step 17: Deleting branch from the local repository

VT: Now, we will delete the branch from our local repository.

First switch to the main branch by running the following command:

$ git checkout main

Now, run the following command to delete the branch from local git repository:

$ git branch -D BRANCH_NAME

📌 Make sure to replace BRANCH_NAME with the name of the branch you were working with.

Output:

Step 18: Synchronizing the fork with the project repository

VT: Finally, if we intend to contribute to this project in the future, we must synchronise our fork with the project repository.

Just run the following command to do so:

$ git pull upstream main
$ git push origin main

Enter the username and password when prompted.

📌 Use your PAT (Personal Access Token) in place of the password.

These commands will pull the most recent changes from the project repository and push them to our fork.

Congratulations on your first contribution to open source!🎉🎉

I hope you found something helpful in this post. You can also follow me on LinkedIn and Twitter.

Cheers and see you in the next one! ✌️

5 Useful Resources That Are Worth Your Time

Vishwas Tyagi — Fri, 26 Aug 2022 14:18:04 +0000

Here are a few articles and video courses that are worth your time:

"Productivity Porn." Caleb Schoepp coined the term to describe anything that, after consumption, makes you feel productive when, in reality, you didn't do anything. It stimulates you without even performing the act, just like regular pornography. Read this article by Caleb Schoepp about productivity porn, examples, and its effects in real life. (5 minute read):
https://calebschoepp.com/blog/2022/productivity-porn/
System design is one of the first decisions we can make when building a system. System design is the process of defining the architecture, interfaces, and data for a system that meets specific requirements. This comprehensive course will teach you almost everything about the system design process, including the OSI model, CDN, databases, and so on. (3.2 hour read):
https://kps.hashnode.dev/system-design-the-complete-course
Docker is an open platform for developing, shipping, and running applications. In this course, you will gain a thorough understanding of the concepts as well as a comprehensive overview of how Docker is used throughout the software development process. The course is a combination of animated theoretical explanations and hands-on demonstrations that you can follow along with. (2.7 hour YouTube course):
https://dev.to/techworld_with_nana/full-docker-course-free-4hl3
Python is the fastest-growing programming language among developers, and companies are using it in almost every industry, such as machine learning and web development. If you want to become a Python developer and looking for a complete 2022 Python Developer RoadMap then this illustrated guide is for you. (8 minute read):
https://medium.com/javarevisited/the-2022-python-programmer-roadmap-bafb365071a3
JavaScript can be used to create a wide variety of games. And JavaScript games can run on almost any device that has a web browser. This course will teach you how to create 2D games using HTML, CSS, and plain vanilla JavaScript, with no frameworks or libraries. (9.6 hour YouTube course):
https://www.freecodecamp.org/news/learn-javascript-game-development-full-course/

Quote: “Focus on being productive instead of busy.” — Tim Ferriss

I hope you found something helpful in this post. You can also find me on LinkedIn and Twitter.

Cheers and see you in the next one! ✌️

Practical Guide to using Git for Beginners

Vishwas Tyagi — Wed, 17 Aug 2022 02:30:00 +0000

Step 1: Install git
Step 2: Configure git
Step 3: Create a new git repository
Step 4: Making changes
Step 5: Committing changes
Undo commits
Git Branches
Merging branches
Deleting a branch
Further reading...
Summary

Mike: I made some changes in my source code and my application broke. Now, I can’t undo the changes that I made earlier.

VT: You should have used git.

Mike: Git? What is that?

VT: Git is a version control system, which tracks the history of changes. As you make changes to the project, any earlier version of the project can be recovered at any time.

Mike: This sounds great! But, how can I use it?

VT: OK! I will show you.

Step 1: Install git

VT: First, download git from http://git-scm.com and install it on your computer.

Mike: OK! Done!

Step 2: Configure git

VT: Configure user information for git. This helps to set your details to all your commits.

Open a terminal (or command prompt) and run the following commands:

$ git config --global user.name "[name]"
$ git config --global user.email "[email address]"

Make sure to replace [name] and [email address] with your real name and email address respectively.

Mike: Done!

Step 3: Create a new git repository

Mike: But what is a git repository?

VT: A Git repository is the .git/ folder inside a project. This repository tracks all changes made to files in your project and builds a history over time.

Mike: But I don’t have a .git/ folder.

VT: First, you have to initialize a git repository.

Open a terminal (or command prompt) in an empty folder (or in your project folder) and run this command:

$ git init

Output:

Initialized empty Git repository in /path/to/your/Project/.git/

Mike: Oh, now I got the .git/ folder. What's next?

If you are not seeing the .git/ folder, turn on the Show Hidden Files option. Usually, it is turned on with Ctrl+H.

VT: That's it. Now you have a git repository where all the changes that you make will be tracked by git.

Let's make some changes now.

Step 4: Making changes

VT: Make a new file (or change the existing one, if any) in the folder where you initialized the git repository.

VT: Let's make an HTML file (index.html), or download an HTML file from here.

VT: Now, you can run this command to see your changes tracked by git.

$ git status

Output:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
    index.html

nothing added to commit but untracked files present (use "git add" to track)

Mike: Done! But what are branch master and commits mentioned in the output?

VT: Hold on! We will talk about branches in a moment. Let's first talk about commits.

Step 5: Committing changes

VT: Commits record file snapshots permanently in the version history.

Let's see how we can commit our changes to the git repository.

VT: First, we have to add our change to the "staging area".

Mike: What is the "staging area"?

VT: The staging area is like a rough draft space, it's where we can add a version of a file (or files) that we want to save in our next commit.

VT: Let's add our index.html file to the "staging area".

Run the following command:

$ git add index.html

OR, we can add all the changes to the staging area at once by running this command:

$ git add .

VT: Now, if we run the command git status, we will get an output something like this:

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
    new file:   index.html

VT: We can commit our stagged changes by running the command:

$ git commit -m "[descriptive message]"

We can add a message to describe our changes by replacing [descriptive message] in the above command.

Output:

[master (root-commit) db027ec] added index.html
 1 file changed, 13 insertions(+)
 create mode 100644 index.html

VT: We have successfully committed our change. We can see all our commits by running the command:

$ git log

Output:

Author: Vishwas Tyagi <vishwast8126@gmail.com>
Date:   Mon Aug 15 19:06:57 2022 +0530

    added index.html

Mike: That's great! But what if I made a commit by mistake? How would I undo any commit?

Undo commits

VT: We can undo any commit at any time by running the git reset command.

VT: Let's see it in action.

Make a change to the index.html file to make another commit.

Add the following line to the index.html file:

<p><strong>Making a change.</strong></p>

Save the file.

Now, on running the git status command we will get the following output:

On branch master
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
    modified:   index.html

no changes added to commit (use "git add" and/or "git commit -a")

VT: Now, let's commit our change.

Run the following commands:

$ git add index.html
$ git commit -m "updated index.html"

VT: Now as we have committed all our changes.

Suppose we made the last commit by mistake and we want to undo that commit.

First, we have to find the hash id of the commit to which we want to go back.

VT: Run the git log command to list all the commits.

commit 3d52d9625962f3147feb760ff7caccbaa2828b36 (HEAD -> master)
Author: Vishwas Tyagi <vishwast8126@gmail.com>
Date:   Mon Aug 15 21:24:29 2022 +0530

    updated index.html

commit db027ecc1d3bd09298db3b0305375047b1e31894
Author: Vishwas Tyagi <vishwast8126@gmail.com>
Date:   Mon Aug 15 19:06:57 2022 +0530

    added index.html

VT: As we want to undo the last commit, we want the hash id of the commit before the last commit.

Run the following command to undo the last commit:

$ git reset [commit_hash_id]

Replace [commit_hash_id] with the hash id of the commit to which you want to go back.

Output:

Unstaged changes after reset:
M   index.html

VT: We have undone the commit and all the changes are sent back to the unstaged area.

Mike: Oh, I got it.

VT: If you want to discard those changes, you can run the following command:

$ git restore index.html

Mike: Great! I got my index.html file restored to the initial state.

Mike: But what are the "branches" that you mentioned earlier?

VT: I think, it's the right time to talk about "branches."

Git Branches

VT: In Git, a branch is a new/separate version of the main repository.

Let's say we have a large project, and we need to work on a new feature.

We can create a new branch (let's say feature) and then we can work on that feature without affecting the main branch.

$ git branch [branch_name]

If we are satisfied with our work, we can merge our branch with the main branch.

If not, then we can return to the main branch and discard the changes we made on the feature branch.

Mike: I am getting it, but I want to see it in action.

VT: Ok, let's get into it.

Suppose we want to add an image to our index.html.

Create a new branch with the name image by running the following command:

$ git branch image

We can list all the branches by running the following command:

$ git branch

Output:

  image
* master

It lists all the branches in the current git repository.

Here, the master is the default main branch.

The asterisk * shows which branch we are currently working on.

To switch branches, run the following command:

$ git checkout image

Output:

Switched to branch 'image'

VT: Now, we can make changes and they will affect only the current branch (image). They will not affect the main branch (master).

Add the following line to index.html:

<img src="https://images.unsplash.com/photo-1471897488648-5eae4ac6686b" height="300" width="200">

Commit the changes:

$ git add .
$ git commit -m "added image in index.html"

VT: Our change is committed but it is only in the image branch. It will not affect the master branch.

We can see this by switching the branch to master.

$ git checkout master

VT: If we inspect the index.html file after switching to the master branch, we can see that the image we added in the index.html file is not there.

This is because the image was added in the image branch.

Mike: How would I merge both the branches?

Merging branches

VT: If we are satisfied with the changes we made in the separate branch, we can merge that branch with the master branch by running git merge [branch_name].

First, switch to branch master:

$ git checkout master

Then run the following command to merge the branch image to the branch master:

$ git merge image

Output:

Updating fa6e17e..c5a4da8
Fast-forward
 index.html | 1 +
 1 file changed, 1 insertion(+)

Deleting a branch

VT: If we no longer want a branch and we want to delete it, we can simply run the git branch -d [branch-name] command.

To delete the branch image in our project:

$ git branch -d image

Output:

Deleted branch image (was c5a4da8).

VT: That's all.

Mike: Oh, that's a lot for me, but by practicing it a few times, I can make it through.

Summary

Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.

In this article, you learned about git repository, git commits, git branches, and how the whole process of version control works.

I hope you enjoyed the article and learned something new. If you want, you can also follow me on LinkedIn or Twitter.

Cheers and see you in the next one! ✌️

Forem: Vishwas Tyagi

Need help with Resume

RESUME - VISHWAS TYAGI.pdf - Google Drive

The Practical Guide to Contributing to Open Source Projects

Table Of Contents

Introduction

Using GitHub

Creating a local git repository

1. Initialize a new git repository

2. Create a file

3. Commit changes

Creating a repository on GitHub

1. Log in to GitHub

2. Create a repository on GitHub

Pushing code to the GitHub repository

1. Add remote to the local git repository

2. Rename the branch from master to main

3. Push code to GitHub

Contributing to Open Source Projects

Step 1: Finding the repository to contribute to

Step 2: Forking the repository

Step 3: Cloning the fork

Step 4: Navigating to local repository

Step 5: Checking the "origin" remote

Step 6: Adding the "upstream" remote

Step 7: Pulling the latest changes

Step 8: Creating a new branch

Step 9: Making changes

Step 10: Committing changes

Step 11: Pushing changes to fork

Step 12: Creating a pull request

Step 13: Discussing the pull request

Step 14: Adding more commits to the existing pull request

Step 15: Discussing the pull request again

Step 16: Deleting branch from the fork

Step 17: Deleting branch from the local repository

Step 18: Synchronizing the fork with the project repository

5 Useful Resources That Are Worth Your Time

Practical Guide to using Git for Beginners

Table Of Contents

Step 1: Install git

Step 2: Configure git

Step 3: Create a new git repository

Step 4: Making changes

Step 5: Committing changes

Undo commits

Git Branches

Merging branches

Deleting a branch

Further reading...

Summary

2. Rename the branch from `master` to `main`