Forem: Tapoban Ray

Git & GitHub: A Beginner’s Complete Guide

Tapoban Ray — Sat, 20 Sep 2025 19:48:42 +0000

In this article, you are going to learn the most basic GitHub commands that you will need in your everyday life as a developer. We will start by creating a repository on your local system and then proceed to creating and merging branches in GitHub.

Feel free to checkout my GitHub and follow me if you find it helpful.

Connecting your remote GitHub account to your local system

Create GitHub account.
Install Git on your system.
Run the following command on your terminal to check if Git has been properly installed on your system.

# This command should display the version of Git installed on your system.
git --version

Then run the following SSH command. Learn more.

ssh-keygen -t ed25519 -C "your_email@example.com"

### Here,
# -t -> specifies the type of key to create
# -C -> Provides custom key comment (which will be appended at the end of the public key).

Learn more about ssh-keygen.

Keep pressing "Enter" after that, and your ssh keys will be generated.

Then open C:/Users/your_username/.ssh/id_ed25519.pub file and copy the entire text present in it.
(NOTE: Open the file with extension .pub, as that file contains the public key.)
Then open your GitHub account > Settings > SSH and GPG keys. Click on New SSH Key. Learn more.
Add your copied public ssh key here and save.
Now, set the name, email and username by using the following commands on your local device.

git config --global user.email "Your email"
git config --global user.name "Your Name"

Creating your first repository and connecting with remote GitHub

Create your local repository by running the following command. Learn More.:

# Create your repository with default branch 'master'
git init

# Create your repository with a custom branch name:
git init -b main

Copy the SSH/https URL of your repository and run the following command inside your new repository folder:

git remote add origin your-repository-url

View all the added remote origins:

git remote -v

Add, Commit and Push

# Add all your changes to staging area by running the following command:
git add . 
# OR 
git add filename1 filname2 ...

# Commit all your changes locally on your system.
git commit -m "commit message" 
# OR
git commit -m "commit message" -m "[OPTIONAL] Description of the commit"

# Publish all your changes remotely on GitHub.
git push origin main 
# OR
git push origin custom_branch_name

Unstage changes
Learn more about Staging Area

# Discard changes done in working directory after last commit
git restore <file>

# Unstage changes.
git restore --staged <file>

# Reset all tracked files in the current directory to the last commit.
git reset .

# Reset the HEAD of our project by one commit
git reset HEAD~1

Why and when to use `git pull`?

Suppose two persons, Person A and Person B are working on a repository from two different computers. Person A makes some changes in the codebase and pushes it to GitHub. Now to, Person B needs to update the code in their system with the new code, or else conflicts might appear. This process of updating the old code present in your local system with the new code present in the remote GitHub repository is accomplished by using the following command:

git pull origin main 
# OR
git pull origin custom_branch_name

Concept of git pull:

It fetches the latest code from remote repository and then merges them into your current branch.
git pull = git fetch + git merge

What is .gitignore file?

Any file or folder that the developer doesn't want to commit and publish on GitHub needs to be listed here. Learn More.

Here's a short example of .gitignore file:

# Ignore node_modules
node_modules/

# Ignore secrets
.env

# Ignore cache folders
pycache/

Check out the pre-designed gitignore templates from GitHub.

Create, edit, push, merge and delete branches

Learn more about Branching in Git

View current working branch and the list of branches present in your local system:

git branch

Create a branch

git branch new_branch_name

Switch to the new branch

git switch branch_name

Publish your branch to remote:

git push origin new_branch_name

Delete a branch from your local system:

# Delete fully merged branch locally
git branch -d branch_name

# Delete branch (even if not merged) locally
git branch -D branch_name

# Delete a branch from remote repository
git push origin --delete branch_name

Fetch a specific branch to your local system

git fetch origin <branch_name>:<branch_name>

Merge your branch into another branch

Suppose you want to merge your changes from branchA to branchB

Checkout to branchB.
Run the following command:

git merge branchA

With this, you’ve covered the most essential Git commands. Once you have a good grasp on these commands and concepts, you can explore advanced concepts like rebasing, stashing, and resolving conflicts.

Git & GitHub: Theoretical concepts

Tapoban Ray — Sun, 14 Sep 2025 05:44:37 +0000

What is Git?

Git is a distributed version control system (DVCS) that helps developers track and manage changes to a project’s files over time. Instead of simply storing data, Git captures snapshots of the entire project at various points (commits), making it possible to review history, collaborate with others, and revert to previous versions when needed.

What is GitHub?

GitHub is a web-based platform that hosts your Git repositories in the cloud. It allows developers to store their code online, collaborate with others, and manage projects using Git.
While Git tracks changes locally on your system, GitHub provides a remote location to push your repositories, making them accessible to others. In addition to repository hosting, GitHub also offers features such as pull requests, issue tracking, project boards, and automation with GitHub Actions.

Why do you need Git & GitHub?

You need Git because it allows you to track changes in your code, experiment safely with new ideas, and revert to previous versions when something goes wrong. For example, suppose you release a mobile app update with a new feature that causes issues. In that case, Git lets you revert your project to a previous commit and continue development in a different branch without losing work.

You need GitHub because it provides a cloud-based platform to share your Git repositories, collaborate with other developers, and work on projects together from anywhere. It also makes contributing to open-source projects easier, as thousands of repositories are publicly hosted on GitHub. Beyond hosting, GitHub offers additional tools like pull requests, issue tracking, project boards, and GitHub Actions to support team workflows.

History of Git and GitHub

Git was originally developed by Linus Torvalds in April 2005 as a distributed version control system for managing the development of the Linux kernel. Shortly after its release, Junio Hamano became and remains the project’s long-term maintainer.

GitHub was launched in April 2008, created by Tom Preston-Werner, Chris Wanstrath, and P. J. Hyett, using Ruby on Rails. Scott Chacon joined early and significantly contributed to its popularity. In June 2018, GitHub was acquired by Microsoft.

Working of Git

The Three States:

Git has three main states that your files can reside in: modified, staged, and committed:

Modifiedmeans that you have changed the file but have not committed it to your database yet.
Stagedmeans that you have marked a modified file in its current version to go into your next commit snapshot.
Committed means that the data is safely stored in your local database.

This leads us to the three main sections of a Git project: the working tree, the staging area, and the Git directory.

The working tree is a single checkout of one version of the project. These files are pulled out of the compressed database in the Git directory and placed on disk for you to use or modify.
The staging area is a file, generally contained in your Git directory, that stores information about what will go into your next commit. Its technical name in Git parlance is the “index”, but the phrase “staging area” works just as well.
The Git directory is where Git stores the metadata and object database for your project. This is the most important part of Git, and it is what is copied when you clone a repository from another computer.

The basic Git workflow goes something like this:

You modify files in your working tree.
You selectively stage just those changes you want to be part of your next commit, which adds only those changes to the staging area.
You do a commit, which takes the files as they are in the staging area and stores that snapshot permanently in your Git directory.

If a particular version of a file is in the Git directory, it’s considered committed. If it has been modified and was added to the staging area, it is staged. And if it was changed since it was checked out but has not been staged, it is modified.

Tracked and Untracked files

Refer to the Git basics to know more about the topic.

Each file in your working directory can be in one of two states: trackedor untracked.

Tracked files are files that were in the last snapshot, as well as any newly staged files; they can be unmodified, modified, or staged. In short, tracked files are files that Git knows about.
Untracked files are everything else — any files in your working directory that were not in your last snapshot and are not in your staging area. When you first clone a repository, all of your files will be tracked and unmodified because Git just checked them out, and you haven’t edited anything.
As you edit files, Git sees them as modified, because you’ve changed them since your last commit. As you work, you selectively stage these modified files and then commit all those staged changes, and the cycle repeats.

Comprehensive Guide to File Handling in Python

Tapoban Ray — Wed, 03 Sep 2025 21:23:25 +0000

File handling is the process of storing, reading, and writing data to and from files permanently on a storage device, rather than just in a computer's memory.

In this tutorial, you are going to learn the following,

Types of files that can be handled in Python.
The modes of opening a file.
Reading from a file.
Writing to a file.
Using tell() and seek() functions.

Types of data files:

Text Files: Stores data in the same format as typed.
1. Regular Text Files (.txt)
2. Delimited Text File.
  1. Tab-Separated Values files (.txt or .csv)
  2. Comma-Separated Values files (.csv)
Binary Files: Stores information in the form of a stream of bytes. Not a human-readable format.

Opening and Closing files in Python

fileObj = open("myfile.txt", mode="r")
fileObj.close()

# -------------------------- OR --------------------------- 

with open("myfile.txt", mode="r") as fileObj:
    data = fileObj.read()
    # Closes file automatically once you get out of this indentation

When using filenames with path, you remember the following:

Always make the file path string a raw string. Using a raw string helps us in ensuring there is no special meaning attached to any character of our file path string.

fileObj = open(r"C:\Temp\data1.txt", mode="r") # Use prefix 'r'

# -------------------------- OR --------------------------- 

fileObj = open("C:\\Temp\\data1.txt", mode="r") # Or use double slashes

Common modes of opening a file:

A file-mode governs the type of operations possible in the opened file.

Text File Mode	Binary File Mode	Description
'r'	'rb'	READ ONLY. File must exist already, or Python raises I/O error.
'w'	'wb'	WRITE ONLY. File is created if it does not already exist. If the file already exists with data, Python overwrites it.
'a'	'ab'	APPEND. File is created if it does not already exist. If the file exists with data, Python retains the data, and new data will be appended to the end.
'r+'	'rb+' or 'r+b'	READ AND WRITE. Properties of READ ONLY mode are applied. Both read and write operations can take place.
'w+'	'wb+' or 'w+b'	WRITE AND READ Properties of WRITE ONLY mode are applied. Both read and write operations can take place.
'a+'	'ab+' or 'a+b	APPEND AND READ File must exist already, or Python raises I/O error.

Reading and Writing files in Python

Writing Text files:

write(str) method -> Writes a string of characters

fileObj.write("Hello World")

writelines([str]) method -> Writes a list of lines.

fileObj.writelines(["Hello 1", "World here"])

Reading Text files:

read(n) method -> Returns a Python String

data = fileObj.read()
# -------------------------- OR --------------------------- 
data = fileObj.read(n) # where n is the number of bytes to read.

readline(n) method -> Returns a line of string ending with '\n'

data = fileObj.readline()
# -------------------------- OR --------------------------- 
data = fileObj.readline(n) # where n is the number of lines to read.

readlines() method -> Returns a list of lines.

data = fileObj.readlines()
# -------------------------- OR --------------------------- 
data = fileObj.readlines()

Reading CSV files:

Opening CSV files with newline="" ensures that no translation of EndOfLine(EOL) character takes place.

import csv

fileObj = open("data.csv", mode="r", newline="")
cReader = csv.reader(fileObj)
for val in cReader:
    print(val)

Writing CSV files:

import csv

fileObj = open("data.csv", mode="w", newline="")
cWriter = csv.writer(fileObj)
cWriter.writerow(["Roll No", "Name", "Marks"]) # Writes only one row

# Writes multiple rows at once.
cWriter.writerows(
    [
        ["01", "Raj", "50"],
        ["02", "Meera", "46"],
        ["03", "Anil", "48"],
    ]
)
fileObj.close()

Writing Binary files:

import pickle

fileObj = open("data.dat", "wb")
data = {"Roll No": 1, "Name": "John", "Marks": 50}
pickle.dump(data, fileObj)
fileObj.close()

Reading Binary files:

import pickle

fileObj = open("data.dat", "rb")
try: 
    while True:
        data = pickle.load(fileObj)
        print(data)

except EOFError:
    fileObj.close()

The `tell()` function

Returns the current position of the file pointer in the file.

pos = fileObj.tell()

The `seek()` function

Changes the position of the file-pointer by placing the file-pointer at the specified position of the opened file.

fileObj.seek(offset, mode)

mode can be 0, 1, or 2.

0 -> Move the file-pointer with respect to the beginning of the file. (DEFAULT MODE)

1 -> Move the file-pointer with respect to the current position of the file.

2 -> Move the file-pointer with respect to the end of the file.

seek() and tell() functions are mostly used when editing a file.

Build a Context-Retaining Chatbot with Langchain-Python

Tapoban Ray — Fri, 29 Aug 2025 19:54:16 +0000

Meaning of Context-Retaining Chatbot

A Context-Retaining chatbot is a chatbot that can remember its previous conversation and respond to the user considering the conversation history.

In this article, we are going to build an AI chatbot using Streamlit as the front-end and the free Gemini API that remembers all its previous conversations, and also host it on Streamlit Community Cloud.

Let's start building the chatbot:

Generate a free Gemini API key.

2.Install the following Python libraries:

langchain
langchain-core
langchain-google-genai
streamlit
watchdog
python-dotenv

3.Save the Google Gemini API key in a .env file.

GEMINI_API_KEY="your-api-key-here"

4.Then we need to use the API key from the .env file in our Python file.

import os
from dotenv import load_dotenv

load_dotenv()

GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")

5.Now, let's implement the AI functionality.

from langchain_google_genai import ChatGoogleGenerativeAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

def generate_output(
    prompt: str,
):
    """Send the prompt to the LLM and return the response."""

    llm = ChatGoogleGenerativeAI(
        model="gemini-2.0-flash-001",
        api_key=GEMINI_API_KEY,
        max_output_tokens=10000,
    )

    output = llm.invoke(prompt)

    return output.content


def get_prompt(human_message: str, system_message: str, chat_history: list):
    """Creates a structured prompt for the LLM."""
    prompt_template = ChatPromptTemplate(
        [
            ("system", system_message),
            (MessagesPlaceholder(variable_name="chat_history")),
            ("human", "{query}"),
        ]
    )

    return prompt_template.invoke(
        {"chat_history": chat_history, "query": human_message}
    )

6.With that, our AI methods are ready. Now we need to build the UI with Streamlit and use these methods in there.

import streamlit as st

CHAT_HISTORY = "chat_history"
SYSTEM_MESSAGE = "system_message"

session_variables = {
    CHAT_HISTORY: [],
    SYSTEM_MESSAGE: "You are a helpful assistant.",
}

for var in session_variables.keys():
    if var not in st.session_state:
        st.session_state[var] = session_variables.get(var)


st.set_page_config(page_title="AI Chatbot")

st.title("AI Chatbot")


st.chat_message("ai").markdown(
    generate_output(
        prompt="Say hi to user in order to initiate conversation in a warm and polite way."
    )
)


def append_to_chat_history(prompt: str):
    """Add every message to the chat_history."""

    final_prompt = get_prompt(
        human_message=prompt,
        chat_history=st.session_state[CHAT_HISTORY],
        system_message=st.session_state[SYSTEM_MESSAGE],
    )
    ai_message = generate_output(
        prompt=final_prompt,
    )
    st.session_state[CHAT_HISTORY].append(("human", prompt))
    st.session_state[CHAT_HISTORY].append(("ai", ai_message))

    st.chat_message("ai").markdown(ai_message)


# Displaying chat history
for chat in st.session_state[CHAT_HISTORY]:
    st.chat_message(chat[0]).write(chat[1])

user_prompt = st.chat_input(
    placeholder="Enter your message...",
)

if user_prompt:
    st.chat_message("human").write(user_prompt)
    append_to_chat_history(prompt=user_prompt)

Done!!! Our AI chatbot is ready. Now, we will host it on Streamlit Community Cloud so that we can share our chatbot with others.

Before doing that, it's better to upload our project to a GitHub repository. For that, we need to run the following commands:

# Initialise git with default branch as 'main'
git init -b main

# Create a new public repository in your GitHub account and then,
# Connect your local git repo with your remote repository.
git remote add origin <url_to_your_remote_repo>

# Move your code to the staging area
git add .

# Commit the code locally on your machine with a commit message.
git commit -m "Built an AI chatbot."

# Upload the code to your remote GitHub repository.
git push origin main

Once your code has been uploaded to the remote GitHub repository, we can now easily host the chatbot via Streamlit Cloud.

Sign up to Streamlit Community Cloud.
Click on Create App in the upper-right corner of the page.
Click on Deploy a public app from GitHub.
Go to Paste GitHub URL and paste the URL of your main.py file from GitHub.
Edit the branch name to main, since that is our default branch name.
Finally, click on Deploy.

Streamlit will take some time to download the required packages and start running.

Our AI chatbot is now fully up and running on Streamlit Community Cloud!
You can now share the URL of your chatbot on your resume or with your friends and family.

Forem: Tapoban Ray

Git & GitHub: A Beginner’s Complete Guide

Contents:

Connecting your remote GitHub account to your local system

Creating your first repository and connecting with remote GitHub

Why and when to use `git pull`?

Concept of `git pull`:

What is .gitignore file?

Create, edit, push, merge and delete branches

Git & GitHub: Theoretical concepts

What is Git?

What is GitHub?

Why do you need Git & GitHub?

History of Git and GitHub

Working of Git

The Three States:

The basic Git workflow goes something like this:

Tracked and Untracked files

Comprehensive Guide to File Handling in Python

In this tutorial, you are going to learn the following,

Types of data files:

Opening and Closing files in Python

Common modes of opening a file:

Reading and Writing files in Python

Writing Text files:

Reading Text files:

Reading CSV files:

Writing CSV files:

Writing Binary files:

Reading Binary files:

The `tell()` function

The `seek()` function

Build a Context-Retaining Chatbot with Langchain-Python

Meaning of Context-Retaining Chatbot

Let's start building the chatbot:

Forem: Tapoban Ray

Git & GitHub: A Beginner’s Complete Guide

Contents:

Connecting your remote GitHub account to your local system

Creating your first repository and connecting with remote GitHub

Why and when to use git pull?

Concept of git pull:

What is .gitignore file?

Create, edit, push, merge and delete branches

Git & GitHub: Theoretical concepts

What is Git?

What is GitHub?

Why do you need Git & GitHub?

History of Git and GitHub

Working of Git

The Three States:

The basic Git workflow goes something like this:

Tracked and Untracked files

Comprehensive Guide to File Handling in Python

In this tutorial, you are going to learn the following,

Types of data files:

Opening and Closing files in Python

Common modes of opening a file:

Reading and Writing files in Python

Writing Text files:

Reading Text files:

Reading CSV files:

Writing CSV files:

Writing Binary files:

Reading Binary files:

The tell() function

The seek() function

Build a Context-Retaining Chatbot with Langchain-Python

Meaning of Context-Retaining Chatbot

Let's start building the chatbot:

Why and when to use `git pull`?

Concept of `git pull`:

The `tell()` function

The `seek()` function