Forem: Aditya Trivedi

Why does a href tag have an underscore '_' ?

Aditya Trivedi — Thu, 09 Apr 2026 12:52:00 +0000

Before HTML5, developers used frameset for SPA-like functionality, dividing the window into multiple frames, each with its own unique name. For e.g, left frame might be name=”sidebar” and right could be name=”content”.

When clicking a link, the browser needed to know which frame to load the content into. That’s where the attribute came in. Clicking a link in sidebar, would load content in content frame:

<a href="/pricing" target="content"></a>

Now if you had a frame named “blank” and used a href=”/” target=blank, the content would load in that frame. But if no frame existed, browser would create a new window and assign it in the “blank” name.

So Why Underscore ?

It’s simple, developers needed a way to explicitly tell the browser to open the link in a new tab, free of frame semantics. The underscore signifies a special value rather than frame name.

Automate your Git Workflow using AI

Aditya Trivedi — Thu, 09 Apr 2026 12:50:41 +0000

Tired of thinking what comments to add for your git commit. This flow will help you.

Prerequisites

Git Bash: Installed on your Windows System.
Ollama CLI: Installed and configured with phi3.5 model.
Basic Knowledge of Git Commands and Terminal Usage.

Step 1: Create the Script File

Open your favorite Text editor and create a new file.

Copy and paste the following Bash Script:

#!/bin/bash
# git_auto_commit.sh

if ! git rev-parse --git-dir > /dev/null 2>&1; then
 echo "Error: This directory is not a Git repository."
 exit 1
fi

if git diff-index --quiet HEAD --; then
 echo "No changes detected. Exiting."
 exit 0
fi

echo "Staging changes..."
git add .

summary=$(git diff --cached --name-only)

echo "Generating commit message suggestion from Ollama phi3.5..."
suggested_commit_msg=$(ollama run phi3.5 ""Generate a concise yet informative commit message that accurately summarizes the following code changes. The message should be clear, professional, and follow best practices for commit messages. Aim to describe the purpose and impact of the changes in a way that is easy to understand. Avoid unnecessary details but ensure the key modifications are covered. Format the message in an imperative style (e.g., 'Fix bug in authentication flow' instead of 'Fixed a bug...'). Here are the changes to summarize: $summary")

echo "Suggested commit message:"
echo "$suggested_commit_msg"

read -p "Edit commit message? (y/n): " choice

if [[ "$choice" =~ ^[Yy]$ ]]; then
   echo "Enter your commit message below. Press Ctrl+D when done."
   commit_msg=$(cat)  # Reads multiline input until Ctrl+D
else
   commit_msg="$suggested_commit_msg"
fi

git commit -m "$commit_msg"
git push origin master
echo "Done!"

Save the file as git_auto_commit.sh.

Step 2: Add the Script to Your Global Bin Directory

Create a bin directory if it doesn’t exist:
```
mkdir -p ~/bin
```
Move the script to this directory:

mv /path/to/git_auto_commit.sh ~/bin/

Step 3: Make the Script Executable inside a bash terminal.

You can use Git Bash as well to execute it here

chmod +x ~/bin/git_auto_commit.sh

Step 4: Add the Script Directory to Your PATH

Open ~/.bashrc or ~/.bash_profile:
```
nano ~/.bashrc
```
Add this line at the end:
```
export PATH="$HOME/bin:$PATH"
```
Save and apply changes:
```
source ~/.bashrc
```

Step 5: Testing the Script

Navigate to a Git repository.
Run:
```
git_auto_commit.sh
```
Follow the prompts.

Additional Notes

Ensure Ollama is installed and running.
Windows NTFS permissions may not reflex Unix-style chmod changes, but the script will execute.

This script is now available at my GitHub Repository. Go ahead and automate your Git Workflow.

GitHub

How to Approach Projects

Aditya Trivedi — Sat, 04 Apr 2026 07:35:39 +0000

Whenever it comes to creating a project or making a project, the most crucial part of it is to have an approach to it. Many a times, what developers do is that they directly start creating the project, rather than understanding what the requirements of the project is.

The way I approach a project is:

1. Initial Planning

Understanding what is the exact requirement in detail
Creating a flowchart understanding what is the flow of the entire project

2. Technology Selection

Based on the flowchart, NOW is when I choose the tech stack to start the project. Now this step also has some conditions while making decision on:

Backend Selection

Fast Processing → NodeJS
Data Processing and Cleaning → Python/Django/Flask
AI or Machine Learning → Python or NodeJs (Personally my choice as there are many libraries which are available here as well)
Security → Java

Frontend Options

NextJS → Fast Loading and Image Optimisation
ViteJS → Faster Development
Or Any other JavaScript Based Frameworks
TalwindCSS/ShadCN → Styling

Database Choices

MongoDB → Super Easy Syntax and easy to connect and also document based
Supabase → OpenSource Structured Database like MYSQL
ChromaDB/PineCone/MongoDB → Vector Embeddings and Vector Search (AI Related Applications)

API Testing Tools

Postman

3. Design Phase

After I am done choosing my Tech Stack, next step is to start with the designing the frontend. For that I usually go for either Figma or Penpot (Open Source Figma Alternative)

4. Development Process

Now this is where a little debate happens, some directly go for frontend development while some start with backend. Don't worry nothing is wrong here, you can start with anything you want.

I personally choose to start with creating the backend first as I think this particularly takes a lot of time developing and most importantly TESTING 😏😏.

I use TDD approach for this which is Test-Driven-Development i.e. create an api → test it with multiple test case you can think of, then move forward with the next one.

5. Frontend Development

Once backend is created, now start with designing the frontend. Always prefer using reusable components in your website so that:

Number of Lines of Code is reduced
Debugging is easier
Code is Reusable

Start creating the frontend using mobile first view as it is very important to have your website both desktop and mobile friendly. Using this approach reduces a lot of your time in development.

6. Integration & Testing

Once the frontend is completed, next task is to start integrating the APIs. This is where all the crucial aspect of any website is implemented.

Once APIs are integrated, next step is to do a thorough testing of the integrated APIs and UI. If the results are as per your requirements, you are good to go for deployment else debug the issues and solve them until and unless you're requirements are not met.

7. Deployment

For Backend deployment I usually prefer:

Render
PythonAnywhere

For Frontend My only way to go is vercel.com

Once this is done, your project is completed. Congratulations 🥳

“Just a small reminder, this approach can be changed based on the scalability and use case of the project.”