Forem: Codespear

How to Remove All Git Commits Locally Without Losing Your Code

K-kibet — Mon, 17 Nov 2025 07:08:40 +0000

When working on a project, there are times you may want to completely remove your Git history — maybe your commit log is messy, you accidentally pushed sensitive details, or you simply want to start fresh. The good news is that you can wipe out every Git commit in a local repository without losing a single line of your code.

In this guide, we’ll walk through a simple and safe way to remove all Git commits locally and start over with clean version control.

## Why Remove Git History?

There are several good reasons developers reset their Git history:

To clean up messy commits and start fresh.
To remove accidentally committed files, like environment variables or API keys.
To prepare a project for open-source release without exposing past work.
To reduce repository size.
To disconnect the project from a previous remote repository.

Whatever your reason is, the process is straightforward.

Method 1: Remove Git Completely (Keep Only Your Code)

If you want to detach the project from Git entirely, use this method. It deletes all Git tracking and history but keeps all your project files safe.

Step 1: Delete the `.git` directory

On macOS/Linux:

rm -rf .git

On Windows (PowerShell):

Remove-Item -Recurse -Force .git

Once the .git folder is gone, the project is no longer a Git repository. None of your files are deleted.

Method 2: Reset Git and Start a Fresh Repo

If you still want the project under Git but with a completely clean commit history, follow these steps:

Step 1: Delete the Git history

rm -rf .git

Step 2: Reinitialize a new Git repository

git init

Step 3: Add all your existing files

git add .

Step 4: Create the first clean commit

git commit -m "Initial commit"

This gives you a brand-new repository with your full project files but zero previous commits.

Optional: Reconnect to a Remote Repository

If you want to push the fresh repo to GitHub, GitLab, or Bitbucket, add your remote:

git remote add origin your-repo-url.git
git push -u --force origin main

⚠️ Warning: Using --force will overwrite the remote history.

Final Thoughts

Clearing your Git history is a powerful way to clean up your project, enhance privacy, or prepare your code for a new workflow. The best part? You don’t lose any of your files — only the commit history is wiped.

Whether you’re cleaning up a personal project or preparing for a professional deployment, starting fresh with a clean Git history can make your repository easier to understand and maintain.

🧹 How to Clear Cache in Windows Using PowerShell (Complete Guide)

K-kibet — Mon, 17 Nov 2025 07:04:44 +0000

Keeping your Windows PC clean and responsive is important—especially if you use it daily for development, gaming, work, or general browsing. Over time, Windows stores piles of temporary files, thumbnails, DNS entries, and other cached data that can slow down your system, eat up disk space, and sometimes cause weird system glitches.

The good news? You can delete all these caches easily using PowerShell, Windows’ powerful command-line tool. This guide walks you through the exact commands you need and explains what each one does.

🔴 Why Clear Cache in Windows?

Windows creates cache files to improve performance, but they can become harmful when:

Apps start running slowly
The system becomes sluggish
Files refuse to open or load
Disk space gets low
Old thumbnails or corrupted temp files cause bugs
DNS cache causes browsing issues

Clearing cache is safe and often fixes these problems.

🟦 PowerShell vs CMD — What’s the Difference?

Many online guides use CMD (Command Prompt) commands like:

del /q/f/s %TEMP%\*

But these do NOT work in PowerShell, because PowerShell uses different syntax and more powerful commands.

So here are the correct and safe PowerShell commands.

🧹 1. Clear User Temporary Files

Your user TEMP folder fills up with leftover files from installers, browsers, and apps.

Run:

Remove-Item "$env:TEMP\*" -Recurse -Force -ErrorAction SilentlyContinue

This wipes all temporary files for the current user account.

🧹 2. Clear Windows Temp Folder

This folder stores system-wide temp files.

Remove-Item "C:\Windows\Temp\*" -Recurse -Force -ErrorAction SilentlyContinue

Make sure you open PowerShell as Administrator for this step.

🧼 3. Flush DNS Cache

If websites fail to load or you get unusual network errors, your DNS cache may be corrupt.

Clear-DnsClientCache

This resets your DNS entries and can instantly fix browsing issues.

🧹 4. Clear Windows Prefetch Cache

The Prefetch folder helps Windows launch programs faster, but it can get bloated.

Remove-Item "C:\Windows\Prefetch\*" -Recurse -Force -ErrorAction SilentlyContinue

Windows rebuilds this folder automatically.

🧹 5. Clear Thumbnail Cache

If File Explorer shows wrong or broken thumbnails, clear them using:

Remove-Item "$env:LocalAppData\Microsoft\Windows\Explorer\thumbcache_*.db" -Force -ErrorAction SilentlyContinue
Stop-Process -Name explorer -Force
Start-Process explorer

Restarting Explorer refreshes your system thumbnail cache immediately.

🧼 6. Reset Microsoft Store Cache

If the Microsoft Store won’t load or shows errors:

Start-Process "wsreset.exe"

This resets all Store-related cache data.

🟩 Combined PowerShell Script (Run All at Once)

If you want a single command set that clears everything, paste this in PowerShell:

Remove-Item "$env:TEMP\*" -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item "C:\Windows\Temp\*" -Recurse -Force -ErrorAction SilentlyContinue
Clear-DnsClientCache
Remove-Item "C:\Windows\Prefetch\*" -Recurse -Force -ErrorAction SilentlyContinue
Remove-Item "$env:LocalAppData\Microsoft\Windows\Explorer\thumbcache_*.db" -Force -ErrorAction SilentlyContinue
Stop-Process -Name explorer -Force
Start-Process explorer
Start-Process "wsreset.exe"
Write-Host "✅ Cache cleanup complete!"

This gives your system a fresh start in under a minute.

🎯 Final Thoughts

Manually cleaning up cache can dramatically improve system responsiveness, free up disk space, and solve minor Windows problems. PowerShell is the most reliable tool for this because it gives full control and avoids errors that CMD-based methods often cause.

Run this cleanup once a month—or any time your PC starts feeling slow—and enjoy a cleaner, faster Windows experience.

How to Connect Your Namecheap Domain to a Render App (Step-by-Step Guide)

K-kibet — Mon, 17 Nov 2025 06:58:03 +0000

If you're hosting your web app on Render and want to use a custom domain from Namecheap, the setup is easier than it looks. In this guide, I’ll walk you through the complete process—from adding your domain on Render to configuring DNS records on Namecheap and enabling HTTPS.

Whether you're deploying a full-stack app, API, or static website, the steps are the same. Let’s get started!

🔧 Step 1: Add Your Custom Domain in Render

Log in to your Render Dashboard.
Open the app you want to connect (Static Site or Web Service).
Navigate to the Settings tab.
Scroll down to Custom Domains.
Click Add Custom Domain.
Enter the domain you purchased from Namecheap (e.g., example.com or www.example.com).
Click Continue.

Render will now generate DNS records that you need to add in your Namecheap dashboard. Keep this page open—you’ll need the values.

🌐 Step 2: Configure DNS Records in Namecheap

Log in to your Namecheap account.
Go to Domain List → click Manage next to your domain.
Switch to the Advanced DNS tab.

Before adding new records:

Remove any old or conflicting DNS records (A, CNAME, URL redirect records).

Now add the records Render provided. Usually, the setup looks like this:

For your main/root domain (`example.com`):

Type	Host	Value (Target)	TTL
A	@	Render IP address (shown in Render)	Auto

For the `www` subdomain (`www.example.com`):

Type	Host	Value (Target)	TTL
CNAME	www	your-app-name.onrender.com (or equivalent)	Auto

If Render gave you unique DNS targets or a different setup, be sure to use the exact values shown on your dashboard.

Once you save your changes, DNS propagation begins. This usually completes within a few minutes but can take up to a few hours.

🔒 Step 3: Enable HTTPS on Render

After your DNS records propagate:

Return to the Custom Domains section in Render.
Wait for Render to verify your domain.
Once verified, click Enable Automatic HTTPS.

Render will automatically issue an SSL certificate via Let’s Encrypt. When completed, your website will be accessible securely via HTTPS.

🧪 Step 4: Test Your Domain

After everything is set up:

Visit https://yourdomain.com
Or https://www.yourdomain.com

You should now see your Render-hosted application running under your custom domain.

If the site doesn’t load immediately, don’t worry—DNS propagation may still be in progress.

🔍 Bonus Tips

Check DNS Propagation

Use tools like:

whatsmydns.net
dnschecker.org

Enter your domain and check if the A and CNAME records have updated globally.

Choose between root or www

You can choose whichever will serve as your primary address:

Primary: example.com ➝ redirect www.example.com
Primary: www.example.com ➝ redirect example.com

Render lets you configure domain redirects easily in the Custom Domains section.

🎉 Final Thoughts

Connecting a custom domain from Namecheap to Render is straightforward once you understand the DNS steps. With your custom domain in place, your project looks more professional, builds trust, and becomes easier for users to access.

🔥 How to Generate a JKS Keystore Without Android Studio (Complete Guide)

K-kibet — Mon, 17 Nov 2025 06:52:14 +0000

A simple tutorial for creating a `.jks` file using Keytool — with fixed passwords, alias, and automated command

Android developers often rely on Android Studio to generate a signing keystore for their apps. But what if you want to create a .jks file without opening Android Studio?
Maybe you're working on a server, CI/CD pipeline, or a lightweight development environment where Android Studio isn't installed.

This guide walks you through:

Installing the JDK (if missing)
Enabling the keytool command
Generating a .jks keystore non-interactively
Using fixed credentials (storePassword, keyPassword, alias)
Creating a matching key.properties file

Let’s get started.

1. The Goal (What We Want to Generate)

We want a .jks file named:

goalkings.jks

With these credentials:

storePassword = goalkings
keyPassword   = goalkings
keyAlias      = goalkings
storeFile     = goalkings.jks

And we want to generate it using a single command, without Android Studio, without answering prompts.

2. Checking If `keytool` Works

Before generating the keystore, we must ensure that Java’s keytool utility is available.

Open PowerShell or CMD and run:

keytool -help

If you get:

The term 'keytool' is not recognized...

…it means the JDK isn't installed or not added to PATH.

Let's fix that.

3. Install the Java Development Kit (JDK)

If Java isn’t installed, download and install a JDK:

Adoptium (recommended): https://adoptium.net
Oracle JDK: https://www.oracle.com/java/technologies/javase-downloads.html

During installation, note where the JDK is installed. Usually:

C:\Program Files\Java\jdk-17\

or:

C:\Program Files\Java\jdk-21\

4. Add JDK to PATH (Windows)

If you installed Java but keytool still doesn’t work, you need to add it to your PATH.

Steps:

Press Win + S → search Environment Variables
Open Edit the system environment variables
Click Environment Variables
Under System Variables, find Path → click Edit
Add the JDK’s bin directory:

C:\Program Files\Java\jdk-17\bin

Click OK
Restart CMD/PowerShell

Now run:

keytool -help

If it outputs help text — you're ready!

5. Generate the JKS File (Non-Interactive Command)

Navigate to your project directory. Example:

cd D:\vscodeProjects\goalkings

Now run this command exactly:

keytool -genkeypair -v -keystore goalkings.jks -storepass goalkings -keypass goalkings -keyalg RSA -keysize 2048 -validity 10000 -alias goalkings -dname "CN=Goalkings, OU=IT, O=Goalkings Ltd, L=Nairobi, S=Nairobi, C=KE"

✔ No prompts
✔ No questions
✔ Generates goalkings.jks instantly

Your keystore will now appear inside the current directory:

D:\vscodeProjects\goalkings\goalkings.jks

6. Verify the Keystore

Check that everything was created correctly:

keytool -list -v -keystore goalkings.jks -storepass goalkings

This displays:

alias name
fingerprints
key algorithm
creation date

7. Create a key.properties File (Android)

Inside your Android project root, create:

`key.properties`

storePassword=goalkings
keyPassword=goalkings
keyAlias=goalkings
storeFile=goalkings.jks

This file is used by your build.gradle for signing.

8. Example `build.gradle` Signing Setup

Inside:

android {
    ...
}

Add:

def keystoreProps = new Properties()
def keystorePropsFile = rootProject.file("key.properties")

if (keystorePropsFile.exists()) {
    keystoreProps.load(new FileInputStream(keystorePropsFile))
}

android {
    signingConfigs {
        release {
            storeFile file(keystoreProps['storeFile'])
            storePassword keystoreProps['storePassword']
            keyAlias keystoreProps['keyAlias']
            keyPassword keystoreProps['keyPassword']
        }
    }

    buildTypes {
        release {
            signingConfig signingConfigs.release
            minifyEnabled false
            shrinkResources false
        }
    }
}

Final Thoughts

You have now:

✔ Installed Java
✔ Enabled keytool
✔ Generated a .jks keystore without Android Studio
✔ Used predefined passwords & alias
✔ Created a key.properties file
✔ Configured signing in Gradle

This method works perfectly for:

CI/CD pipelines
Server builds
Flutter projects
React Native Android builds
Lightweight development setups

📦 Managing Multiple Projects in One Repository: Submodules, Subtrees, Monorepos & Partial Cloning Explained

K-kibet — Mon, 17 Nov 2025 06:27:57 +0000

Modern software development often involves several related projects that need to live together—perhaps a shared library, a mobile app, an admin dashboard, and a backend API. Managing these independently while keeping them organized in a single place requires the right Git strategy.

In this guide, we’ll explore four powerful approaches to organizing multiple projects under one repository:

Git Submodules
Git Subtrees
Monorepo structure
Partial cloning using sparse-checkout

Each technique has its strengths and ideal use cases. Let’s break them down with clear examples.

🔧 1. Git Submodules — Independent Projects Inside a Parent Repository

Git submodules let you embed separate Git repositories inside a parent repository. Each submodule maintains its own commit history and remote origin.

✔ When to Use Submodules

When projects must remain completely independent
When you want separate version control per project
When reused modules belong in multiple repositories

📌 Example Use Case

Main project: mega-suite
Submodules:

ui-engine
data-analyzer

📥 Adding a Submodule

git submodule add https://github.com/example/ui-engine.git modules/ui-engine
git commit -m "Added ui-engine as submodule"

This creates a .gitmodules file that tracks submodule entries.

▶ Initialize & Update Submodules

git submodule update --init --recursive

🔄 Working Inside a Submodule

cd modules/ui-engine
git checkout main

💡 Pros

Clean separation
Reusable modules
Independent version history

⚠ Limitations

Can confuse beginners
Requires extra commands to sync
Submodules can break if misconfigured

🌳 2. Git Subtrees — Embed Projects Without Complexity

Git subtrees merge another repository into a folder inside your repo—without the extra complexity of submodules.

✔ When to Use Subtrees

When you want all code in one repo
But still want to pull updates from external repos
And you don’t want the overhead of submodules

📌 Example Use Case

Main repository: mega-suite
Subtree projects:

ui-engine
data-analyzer

➕ Add a Subtree

git remote add ui-engine https://github.com/example/ui-engine.git
git subtree add --prefix=modules/ui-engine ui-engine main --squash

🔄 Updating the Subtree

git subtree pull --prefix=modules/ui-engine ui-engine main --squash

💡 Pros

Everything stored inside one repo
No special clone commands
Easier than submodules
No detached HEAD issues

⚠ Limitations

Repo size grows faster
No true isolation between projects

🏢 3. Monorepos — A Single Repo for Multiple Projects

A monorepo is a repository where all projects live together—even if they are unrelated. Big companies like Google, Meta, and Microsoft use monorepos to streamline development.

✔ When to Use a Monorepo

When projects depend on each other
When you want shared tooling and libraries
When you want centralized versioning

📁 Example Monorepo Structure:

mega-suite/
├── apps/
│   ├── dashboard/
│   └── mobile/
├── services/
│   ├── auth-service/
│   └── billing-service/
└── shared/
    ├── ui-kit/
    └── utils/

💡 Pros

Easy refactoring across multiple projects
Shared code lives in one place
One repository to maintain
Unified versioning

⚠ Limitations

Repo can grow very large
Requires tooling (NX, Lerna, Turborepo)
Requires discipline to maintain structure

📥 4. Partial Cloning — Clone Only the Project You Need

Partial cloning (via sparse-checkout) allows users to clone only specific folders instead of the entire repository. This is perfect for monorepos.

✔ When to Use Sparse-Checkout / Partial Cloning

Repo is too large
Developers work on only one project
You want to save disk space and bandwidth

📌 Example Setup

Monorepo: mega-suite
Folders:

apps/dashboard
apps/mobile

🧩 Clone Repo Without Checkout

git clone --no-checkout https://github.com/example/mega-suite.git
cd mega-suite

🔧 Initialize Sparse Checkout

git sparse-checkout init
git sparse-checkout set apps/dashboard

▶ Checkout Files

git checkout main

Now only the dashboard project is downloaded!

💡 Pros

Works perfectly with monorepos
Saves disk space
Developers download only what they need

⚠ Limitations

Requires Git 2.25+
Adds a bit of setup complexity

🎯 Which Approach Should You Choose?

Use Case	Best Method
Projects must remain fully independent	Submodules
Want all code in one repo but keep external sources	Subtrees
Multiple related apps/libraries in one place	Monorepo
Only need to clone specific folders	Partial cloning

🚀 Final Thoughts

Organizing multiple projects under one Git repository isn’t one-size-fits-all. Each method—submodules, subtrees, monorepos, and partial cloning—serves a different purpose.

For strict independence → Submodules
For simpler integration → Subtrees
For large ecosystems → Monorepos
For large repos requiring selective cloning → Partial cloning

Pick the strategy that fits your workflow and scale your projects with confidence.

How to Install Node.js and Android Development Tools on a Custom Drive in Windows

K-kibet — Mon, 17 Nov 2025 05:37:04 +0000

Your complete guide to managing development tool installations on Windows when you need them on a different drive.

Introduction

As developers, we often face storage constraints on our primary C: drive, especially when working with multiple development environments, Android projects, and Node.js applications. This comprehensive guide walks you through the process of installing and configuring essential development tools on alternative drives in Windows.

The Challenge: Moving Beyond the C: Drive

By default, most development tools install to the C: drive. However, with large SDKs, multiple Node.js projects, and various dependencies, you might quickly run out of space. Here's how to take control of your development environment installation locations.

Part 1: Installing Node.js on D: Drive with Chocolatey

Understanding Chocolatey Installation Locations

Chocolatey, the Windows package manager, uses several environment variables to determine installation locations:

ChocolateyInstall: Main Chocolatey directory
ChocolateyBinRoot: Binary tools location
ChocolateyToolsLocation: Additional tools directory

Step-by-Step Installation Process

Method 1: Environment Variable Approach

# Set custom installation locations
$env:ChocolateyInstall = 'D:\Chocolatey'
$env:ChocolateyBinRoot = 'D:\Tools'
$env:ChocolateyToolsLocation = 'D:\Tools'

# Install Node.js LTS
choco install -y nodejs-lts

Method 2: Package-Specific Parameters

# Direct installation to custom directory
choco install -y nodejs-lts --params="'/InstallDir:D:\nodejs'"

Method 3: Permanent Configuration

For a permanent setup, set system environment variables:

[Environment]::SetEnvironmentVariable("ChocolateyInstall", "D:\Chocolatey", "Machine")
[Environment]::SetEnvironmentVariable("ChocolateyBinRoot", "D:\Tools", "Machine")
[Environment]::SetEnvironmentVariable("ChocolateyToolsLocation", "D:\Tools", "Machine")

Important Note: Always run PowerShell as Administrator when changing system-wide settings or installing software that requires system modifications.

Common Issues and Solutions

Administrator Rights Required

# Error: "Chocolatey detected you are not running from an elevated command shell"
# Solution: Run PowerShell as Administrator

Package Already Installed

# If Node.js is already installed on C: drive
choco install -y nodejs-lts --force --params="'/InstallDir:D:\nodejs'"

# Or uninstall first, then reinstall
choco uninstall nodejs-lts -y
choco install -y nodejs-lts --params="'/InstallDir:D:\nodejs'"

Part 2: Finding and Configuring Android Development Tools

Locating Android SDK and JDK

When working with Android development, you need to locate or install two key components:

Java Development Kit (JDK)
Android SDK

Finding Existing Installations

# Check environment variables
echo $env:JAVA_HOME
echo $env:ANDROID_HOME

# Search for JDK installations
Get-ChildItem -Path "C:\" -Name "*jdk*" -Directory -ErrorAction SilentlyContinue
Get-ChildItem "C:\Program Files\Java\" -ErrorAction SilentlyContinue

# Search for Android installations  
Get-ChildItem -Path "C:\" -Name "*android*" -Directory -ErrorAction SilentlyContinue
Get-ChildItem "C:\Program Files\Android\" -ErrorAction SilentlyContinue

Common Installation Locations

Android Studio JDK

C:\Program Files\Android\Android Studio\jbr\

Android SDK (Default Location)

C:\Users\[Username]\AppData\Local\Android\Sdk

Standard JDK Locations

C:\Program Files\Java\jdk-[version]\
C:\Program Files (x86)\Java\jdk-[version]\

Setting Up Environment Variables

Temporary (Current Session Only)

$env:JAVA_HOME = "C:\Program Files\Android\Android Studio\jbr"
$env:ANDROID_HOME = "C:\Users\$env:USERNAME\AppData\Local\Android\Sdk"

Permanent Configuration

[Environment]::SetEnvironmentVariable("JAVA_HOME", "C:\Program Files\Android\Android Studio\jbr", "User")
[Environment]::SetEnvironmentVariable("ANDROID_HOME", "C:\Users\$env:USERNAME\AppData\Local\Android\Sdk", "User")

Verification Steps

# Verify Java installation
& "$env:JAVA_HOME\bin\java.exe" -version

# Verify Android SDK accessibility
Test-Path "$env:ANDROID_HOME\platform-tools\adb.exe"

# Check environment variables
echo "JAVA_HOME: $env:JAVA_HOME"
echo "ANDROID_HOME: $env:ANDROID_HOME"

Part 3: Advanced Configuration

Custom npm Global Installation Directory

If you want to keep global npm packages on your D: drive:

# Set custom npm prefix
npm config set prefix "D:\npm-global"

# Update PATH temporarily
$env:PATH = "D:\npm-global;" + $env:PATH

# For permanent PATH update
[Environment]::SetEnvironmentVariable("Path", "D:\npm-global;" + [Environment]::GetEnvironmentVariable("Path", "User"), "User")

Moving Existing Installations

For tools already installed on C: drive:

# Check current installation
Get-Command node
npm config get prefix

# Reinstall to new location
choco uninstall nodejs-lts -y
choco install -y nodejs-lts --params="'/InstallDir:D:\nodejs'"

Part 4: Troubleshooting Common Issues

Chocolatey Installation Problems

Issue: Test-ProcessAdminRights not recognized
Solution: Run PowerShell as Administrator or reinstall Chocolatey

Issue: Directory does not exist errors

Solution: Create directories manually first:

mkdir D:\Chocolatey -Force
mkdir D:\Tools -Force

Environment Variable Problems

Issue: Variables not persisting after reboot
Solution: Use [Environment]::SetEnvironmentVariable with "Machine" or "User" scope instead of temporary session variables

Issue: Tools not found after moving
Solution: Verify PATH includes new installation directories and restart terminal

Best Practices

Always test installations after moving to new locations
Keep backups of important projects before making system changes
Document your configuration for future reference
Use version control for configuration files
Regularly update your development tools

Conclusion

Managing development tool installations on custom drives in Windows requires understanding of environment variables, package manager configurations, and system PATH settings. By following this guide, you can effectively organize your development environment across multiple drives, overcome storage limitations, and maintain an efficient workflow.

The key takeaways are:

Use Chocolatey environment variables for bulk tool management
Set JAVA_HOME and ANDROID_HOME for Android development
Configure npm prefix for Node.js package management
Always verify installations after configuration changes
Keep system and user environment variables organized

With these techniques, you can optimize your Windows development environment for better storage management and workflow efficiency.

This guide covers the complete journey from initial installation challenges to a fully configured development environment. Whether you're setting up a new machine or optimizing an existing one, these steps will help you maintain control over your development tool locations.

Solving the "src refspec main does not match any" Git Error: A Comprehensive Guide

K-kibet — Mon, 17 Nov 2025 05:20:17 +0000

If you're reading this, you've probably encountered the frustrating Git error:

error: src refspec main does not match any
error: failed to push some refs to 'your-repository.git'

Don't worry—this is one of the most common Git errors developers face today, especially with the transition from master to main as the default branch name. In this comprehensive guide, we'll explore what this error means, why it happens, and multiple ways to fix it.

Understanding the Error

What Does "src refspec main does not match any" Mean?

Simply put, Git is telling you: "I looked for a branch called main in your local repository, but I couldn't find it." The src refspec refers to the source reference specification—in this case, the branch you're trying to push.

Why This Happens: The Great Branch Name Transition

In 2020, GitHub and other Git hosting platforms changed their default branch name from master to main. This change created a disconnect between:

New repositories: Created with main as default
Older repositories/Git configurations: Still using master
Local Git installations: Might be configured with either default

Step 1: Diagnosis - What's Actually in Your Repository?

Before fixing the problem, let's understand your current situation.

Check Your Local Branches

git branch -a

This command shows all branches in your repository. Look for:

* main - you're on main branch (unlikely if you're getting the error)
* master - you're on master branch
No asterisk? You might not be on any branch!

Check Remote Branches

git ls-remote --heads origin

This shows what branches exist on the remote repository.

Step 2: Solutions - Pick the Right One for Your Situation

Solution 1: You Have a `master` Branch Instead

If git branch -a shows master but not main:

# Push your master branch to main on remote
git push -u origin master:main

# Or simply push master to master
git push -u origin master

To rename your local branch to match modern standards:

git branch -M master main
git push -u origin main

Solution 2: You Have No Commits Yet (New Repository)

If you haven't made any commits:

# Stage all your files
git add .

# Create your first commit
git commit -m "Initial commit"

# Ensure you're on main branch (create if needed)
git branch -M main

# Push to main
git push -u origin main

Solution 3: You Have Commits But No Main Branch

If you have commits but no main branch:

# Check what branch you're on
git status

# Create main branch from your current work
git checkout -b main

# Push the new main branch
git push -u origin main

Solution 4: The Nuclear Option - Reset and Recreate

If nothing else works:

# Check your current status
git log --oneline

# Create main branch from current state
git branch -M main

# If the remote has conflicting branches, force push
git push -f -u origin main

Warning: Use -f (force push) carefully, as it can overwrite remote changes.

Step 3: Configuration - Prevent Future Issues

Set Main as Your Default Branch

# Set main as default branch for new repositories
git config --global init.defaultBranch main

# Check your current configuration
git config --global init.defaultBranch

Update Existing Repository Default Branch

On GitHub:

Go to your repository → Settings → Branches
Click "⚙️" next to "Default branch"
Change from master to main

Then update your local repository:

git fetch origin
git branch -u origin/main main

Common Scenarios and Quick Fixes

Scenario 1: Just Cloned a Repository

# Check what branch was cloned
git branch -a

# If you see remotes/origin/main but no local main
git checkout main

Scenario 2: Working with Legacy Code

# If the project still uses master
git push -u origin master

# To modernize it
git branch -M master main
git push -u origin main

Scenario 3: Empty Repository

# If you created an empty repo on GitHub
echo "# Project Name" > README.md
git add README.md
git commit -m "Initial commit"
git branch -M main
git push -u origin main

Best Practices to Avoid This Error

Check Before You Push: Always run git branch -a to see available branches
Consistent Naming: Use main for all new projects
Update Git: Use the latest Git version for better defaults
Team Alignment: Ensure your team agrees on branch naming conventions

Troubleshooting Checklist

[ ] Run git branch -a to see local branches
[ ] Run git status to check your current state
[ ] Run git ls-remote --heads origin to see remote branches
[ ] Check if you have any commits with git log --oneline
[ ] Verify your remote URL with git remote -v

Conclusion

The "src refspec main does not match any" error is a common side effect of the industry's transition from master to main as the default branch name. While frustrating, it's usually easy to fix once you understand your repository's current state.

The key is to diagnose first (check what branches exist) then apply the appropriate solution for your situation. With the methods outlined in this guide, you should be able to resolve this error and get back to coding quickly.

Remember: this is a transitional issue that will become less common over time as the ecosystem fully adopts main as the standard default branch name.

Happy coding! 🚀

How to Configure A and CNAME Records in Namecheap (When You Can't Find the Option)

K-kibet — Mon, 17 Nov 2025 05:13:45 +0000

Struggling to find where to add DNS records in your Namecheap dashboard? This step-by-step guide will show you exactly how to access the correct page and configure your records.

Meta Description: Learn how to configure A and CNAME records in Namecheap with this clear guide. Fix the common "can't find DNS settings" issue and take control of your domain's DNS.

If you've ever needed to point your domain to a new web host or set up a subdomain, you know you need to configure DNS records. The theory is simple: add an A Record to point to an IP address, or a CNAME Record to create a subdomain alias.

But when you log into Namecheap, the reality is often frustrating. You might find yourself on a page that offers no clear way to add these records, with confusing sections like "Server," "Access," and "Apps," and prompts that say:

"You can transfer DNS back to Namecheap BasicDNS to take advantage of our free Domain Redirect..."

If this looks familiar, you're in the right place. This guide will show you how to navigate this problem and successfully configure your DNS records.

Why You Can't Find the DNS Settings

The page you're seeing is not the DNS management panel. It's a general overview page. The reason you can't see the option to "Add Record" is almost always the same:

Your domain is not using Namecheap's default nameservers.

When your domain is set to "Custom DNS," Namecheap hides the standard DNS management tools because you're meant to manage your records elsewhere (like at Cloudflare, your VPS provider, etc.). To use Namecheap's built-in, user-friendly DNS editor, you must first switch to using Namecheap BasicDNS.

How to Configure Your Nameservers for DNS Access

Before you can configure A and CNAME records, you need to ensure you're on the right system. Here’s how to do it.

Step 1: Go to Your Domain List

Log into your Namecheap account.
From the top menu, click "Account" and then select "Domain List." You can also click "Domain List" directly from your dashboard if you see it.

Step 2: Manage Your Domain

In your domain list, find the domain you want to configure (e.g., yourdomain.com).
Click the "Manage" button next to it.

Step 3: Switch to Namecheap BasicDNS

On the management page, find the "Nameservers" section.
If it's set to "Custom DNS," change it to "Namecheap BasicDNS" using the dropdown menu.
Click "Save" or "Confirm" to apply the change.

Note: This change can take 4-24 hours to fully propagate, but it's often much faster. Your website and email might be temporarily affected during this transition if they were using the old nameservers.

How to Setup A and CNAME Records

Once you've completed the steps above, the DNS management panel will become available. Here's how to use it.

Step 4: Access the DNS Management Panel

After setting your nameservers to "Namecheap BasicDNS," a new tab or menu item called "Advanced DNS" will appear. Click on it.
You will now see the "HOST RECORDS" section. This is where you configure all your DNS records.

How to Configure an A Record

An A record points a hostname (like www.yourdomain.com) to an IP address.

In the "HOST RECORDS" section, click the "ADD NEW RECORD" button.
Select "A Record" from the type dropdown.
Fill in the fields:
- Host: Enter the subdomain. Use @ for the root domain (yourdomain.com) or www for www.yourdomain.com.
- Value: Enter the IP address provided by your hosting company (e.g., 192.0.2.1).
- TTL: Leave this on "Automatic."
Save the record by clicking the checkmark or floppy disk icon.

How to Setup a CNAME Record

A CNAME record points a hostname to another hostname. It's commonly used for subdomains like mail.yourdomain.com pointing to a service like ghs.google.com.

Click the "ADD NEW RECORD" button.
Select "CNAME Record" from the dropdown.
Fill in the fields:
- Host: Enter the subdomain prefix (e.g., mail, shop, blog).
- Value: Enter the destination hostname (e.g., ghs.google.com).
- TTL: Leave this on "Automatic."
Save the record.

Troubleshooting and Final Checklist

If you're still having trouble, run through this checklist:

✅ Are you on the right page? You should be at: Domain List → [Your Domain] → Manage → Advanced DNS.
✅ Are your nameservers correct? They must be set to "Namecheap BasicDNS" to see the "HOST RECORDS" section.
✅ Have you waited? If you just changed nameservers, wait at least 30 minutes and refresh the page.

By following these steps, you've learned not just how to add DNS records, but how to resolve the most common configuration issue that prevents users from managing their DNS in the first place. You now have the knowledge to point your domain wherever it needs to go.

From Development to Production: A Complete Guide to Deploying Node.js Applications on Google Cloud

K-kibet — Mon, 17 Nov 2025 05:09:13 +0000

Navigating the journey from local development to successful cloud deployment with custom domain integration

Introduction

Deploying a web application to production involves numerous steps that go beyond writing code. This comprehensive guide documents the complete process of taking a Node.js application from local development to a fully deployed cloud service with custom domain integration. Through real-world challenges and solutions, we'll explore the deployment journey on Google Cloud Platform.

The Application Overview

Our case study involves a full-stack web application with the following characteristics:

User authentication and session management
Payment gateway integrations
Database persistence
Template rendering for views
Real-time user interactions
Multiple API integrations

Phase 1: Initial Cloud Environment Setup

Configuration and Authentication

The deployment journey begins with proper cloud environment configuration:

# Initialize cloud configuration
gcloud init

Configuration Steps:

Create a new configuration profile
Select appropriate Google account
Choose target cloud project
Set default deployment region

Overcoming Initial Hurdles

Early in the process, we encountered file system permission issues:

# Initial configuration attempt failed due to permissions
gsutil config -n

# Resolution required administrative privileges
# Running terminal as administrator resolved the issue

Key Insight: Cloud tools often require elevated permissions when installed in system directories. Running command-line tools as administrator resolves many permission-related challenges.

Phase 2: Deployment Strategy and Execution

Choosing the Right Deployment Service

Google Cloud offers multiple deployment options. We evaluated:

Cloud Run: Container-based deployment with automatic scaling
App Engine: Platform-as-a-Service with managed infrastructure
Compute Engine: Virtual machine instances with full control

Initial Deployment Attempt

Our first deployment used Cloud Run with source-based deployment:

# Deploy from source code
gcloud run deploy application-name --source . --region chosen-region --allow-unauthenticated

Critical Container Configuration

The initial deployment failed due to a common container misconfiguration:

Original Application Code:

app.listen(port, () => {
    console.log(`Server running on port ${port}`);
});

Production-Ready Configuration:

app.listen(port, '0.0.0.0', () => {
    console.log(`Server running on port ${port} on all interfaces`);
});

Why This Matters: Cloud containers must listen on all network interfaces (0.0.0.0) rather than localhost-only binding to accept external traffic.

Environment Configuration

Production deployment requires proper environment variable management:

# Set environment variables during deployment
gcloud run deploy application-name --source . --region chosen-region --allow-unauthenticated --set-env-vars="DATABASE_URL=connection-string,API_KEY=secret-key,SESSION_SECRET=secure-secret"

Essential Production Variables:

Database connection strings
Third-party API credentials
Application secrets and keys
Environment-specific configurations

Phase 3: Addressing Deployment Failures

The Silent Failure Pattern

Despite successful build processes, the application returned service unavailable errors. The deployment appeared successful, but the container failed to start properly.

Log Analysis Methodology

The key to troubleshooting was comprehensive log analysis:

# Monitor real-time application logs
gcloud app logs tail

# Review recent log entries
gcloud app logs read --limit=50

Dependency Management Crisis

Log analysis revealed missing dependencies:

Error: Cannot find module 'required-dependency'
Require stack:
- /workspace/routes/api-route.js
- /workspace/main-application-file.js

Root Cause: The application code required external packages that weren't specified in the dependency manifest file.

Dependency Resolution

The solution involved comprehensive dependency management:

Updated Package Configuration:

{
  "dependencies": {
    "web-framework": "^4.18.0",
    "database-driver": "^7.0.0",
    "security-middleware": "^2.8.5",
    "session-management": "^1.17.0",
    "environment-management": "^16.0.0",
    "template-engine": "^3.1.0",
    "http-client": "^1.6.0"
  }
}

Resolution Steps:

Install missing dependencies locally
Update dependency manifest file
Redeploy application
Verify all dependencies are properly resolved

Phase 4: Custom Domain Integration

Domain Verification Process

Connecting a custom domain involves multiple verification steps:

Retrieve Cloud Service URL:

   gcloud app browse

Initiate Domain Verification:
- Access cloud console domain management
- Add custom domain for verification
- Complete domain ownership validation

DNS Configuration

Root Domain Configuration (A Records):

Type: A | Host: @ | Value: 216.239.32.21 | TTL: 1800
Type: A | Host: @ | Value: 216.239.34.21 | TTL: 1800
Type: A | Host: @ | Value: 216.239.36.21 | TTL: 1800
Type: A | Host: @ | Value: 216.239.38.21 | TTL: 1800

Subdomain Configuration (CNAME):

Type: CNAME | Host: www | Value: ghs.googlehosted.com | TTL: 1800

Application Configuration Updates

After domain mapping, update application settings:

// Update CORS and security settings for new domain
app.use(cors({
    origin: [
        'https://custom-domain.com',
        'https://www.custom-domain.com',
        'https://original-cloud-url.region.r.appspot.com'
    ],
    credentials: true,
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']
}));

Critical Lessons Learned

1. Deployment Best Practices

Always test container binding to 0.0.0.0
Validate all environment variables in production context
Implement comprehensive health check endpoints
Use separate configurations for development and production

2. Dependency Management

Maintain accurate dependency manifests
Conduct regular dependency audits
Use lock files for consistent installations
Document all external package requirements

3. Troubleshooting Methodology

Start investigation with application logs
Reproduce issues in local environments when possible
Use minimal test cases to isolate problems
Document resolution steps for future reference

4. DNS and Network Considerations

Understand DNS propagation timeframes
Configure proper SSL/TLS certificates
Plan for domain transition periods
Monitor SSL certificate provisioning

Architecture and Infrastructure

The final production architecture includes:

Application Hosting: Managed cloud platform service
Database: Cloud-based database service
Payments: Multiple payment gateway integrations
Domain Management: External DNS provider with cloud integration
Security: Automated SSL certificate management
Monitoring: Built-in logging and performance monitoring

Security Implementation

Credential Management:
- Use cloud secret management services
- Never hardcode sensitive information
- Implement proper key rotation policies
Application Security:
- Configure secure session management
- Implement proper CORS policies
- Use environment-specific security settings
Infrastructure Security:
- Leverage cloud platform security features
- Implement proper access controls
- Regular security scanning and updates

Performance Optimization Strategies

Application Performance:
- Database connection optimization
- Response compression implementation
- Static asset delivery optimization
Infrastructure Optimization:
- Geographic region selection
- Auto-scaling configuration
- CDN integration for global performance
Monitoring and Analytics:
- Performance metric collection
- User behavior analysis
- Error rate monitoring and alerting

Conclusion

The journey from local development to production deployment involves numerous considerations beyond application code. Successful deployment requires:

Proper cloud environment configuration
Comprehensive dependency management
Strategic troubleshooting approaches
Careful domain and DNS configuration
Ongoing performance and security monitoring

This guide demonstrates that while cloud deployment presents challenges, systematic approaches and proper tooling can transform complex deployment processes into manageable, repeatable procedures. The result is a robust, scalable production application serving users worldwide with reliable performance and security.

Key Takeaways:

Cloud deployment requires both technical and strategic planning
Log analysis is the most powerful troubleshooting tool
Dependency management is critical for successful deployments
Custom domain integration, while complex, follows predictable patterns

Future Considerations:

Implementing continuous integration/continuous deployment pipelines
Adding comprehensive monitoring and alerting systems
Planning for scalability and traffic growth
Regular security reviews and updates

The successful deployment marks not the end, but the beginning of the application's production lifecycle, requiring ongoing maintenance, monitoring, and improvement.

How to Host Your Website with Namecheap Domain and Render: A Complete Guide with Free SSL

K-kibet — Mon, 17 Nov 2025 05:01:58 +0000

Learn how to seamlessly connect your Namecheap domain to Render hosting with automatic SSL certificates

Introduction

In today's digital landscape, having a professional online presence is crucial for businesses, developers, and content creators alike. While there are numerous hosting platforms available, Render stands out for its simplicity, performance, and generous free tier. When combined with a Namecheap domain, you get a powerful, cost-effective solution for hosting your website.

The best part? Render provides free SSL certificates automatically, ensuring your site is secure without any additional cost or configuration hassle.

Why Choose Render with Namecheap?

Benefits of This Combination

💰 Cost-Effective: Namecheap offers affordable domains while Render provides excellent free tier hosting
🔒 Automatic Security: Free SSL certificates included
⚡ Blazing Fast Performance: Global CDN and optimized infrastructure
🎯 Easy Setup: Straightforward domain configuration
🔄 Continuous Deployment: Git integration for automatic updates
📈 Scalable: Grows with your traffic needs

Perfect For

Personal portfolios and blogs
Small business websites
Startup MVPs (Minimum Viable Products)
Static sites and JAMstack applications
Full-stack web applications

Step-by-Step Setup Guide

Prerequisites

A Namecheap domain
A Render account (free)
Your website code (HTML/CSS/JS or any framework)

Step 1: Deploy Your Website to Render

1.1 Create a Render Account

Visit render.com
Sign up using your GitHub, GitLab, or Google account
Verify your email address

1.2 Choose Your Service Type

Render offers different service types depending on your needs:

For Static Sites (HTML, CSS, JavaScript):

Choose "Static Site"
Perfect for portfolios, blogs, documentation
Unlimited free sites

For Dynamic Applications (Node.js, Python, etc.):

Choose "Web Service"
Ideal for full-stack applications
750 free hours monthly

1.3 Connect Your Repository

Click "New +" button
Select your service type
Connect your GitHub/GitLab repository
Configure build settings:
- Build Command: npm run build (if needed)
- Publish Directory: public or dist
Click "Create Service"

Render will automatically build and deploy your application, providing you with a .onrender.com subdomain.

Step 2: Add Your Custom Domain in Render

2.1 Access Domain Settings

Go to your Render dashboard
Click on your deployed service
Navigate to Settings tab
Click on Domains section

2.2 Add Your Domain

Click "Add Custom Domain"
Enter your domain name (e.g., yourdomain.com or www.yourdomain.com)
Render will display the required DNS records

Important: Render supports both root domains (yourdomain.com) and subdomains (www.yourdomain.com).

Step 3: Configure Namecheap DNS Settings

3.1 Access Namecheap DNS Management

Log into your Namecheap account
Go to Domain List
Click "Manage" next to your domain
Navigate to "Advanced DNS" tab

3.2 Recommended Setup: Redirect Root to WWW

This approach simplifies SSL setup and ensures consistent URLs:

For www subdomain (Primary):

Type: CNAME
Host: www
Value: your-service.onrender.com
TTL: Automatic

For root domain redirect:

Type: URL Redirect
Host: @
Value: https://www.yourdomain.com
TTL: 30 min

3.3 Alternative: Direct Root Domain Setup

If you prefer using the root domain directly:

Type: CNAME
Host: @
Value: your-service.onrender.com
TTL: Automatic

Note: Some registrars don't support CNAME records for root domains. If Namecheap doesn't allow this, use the redirect method above.

Step 4: Automatic SSL Certificate Provision

4.1 How Render Handles SSL

Automatic Detection: Render detects your domain once DNS propagates
Free Certificate: Uses Let's Encrypt for SSL certificates
Auto-Renewal: Certificates automatically renew before expiration
HTTPS Enforcement: All HTTP traffic redirected to HTTPS

4.2 Waiting for Propagation

DNS changes take 1-24 hours to propagate globally
Render automatically starts SSL certificate process
You'll receive email confirmation from Render
Check status in Render dashboard under Domains

4.3 Verification

Visit https://yourdomain.com
Look for 🔒 lock icon in browser address bar
Certificate should show as valid and secure

Advanced Configuration Options

Environment Variables

Configure environment-specific settings in Render dashboard:

Go to your service → Environment tab
Add key-value pairs for:
- API keys
- Database URLs
- Feature flags
- Configuration settings

Custom Headers

Add security headers in Render static site settings:

{
  "headers": [
    {
      "source": "**/*",
      "headers": [
        {
          "key": "X-Frame-Options",
          "value": "DENY"
        },
        {
          "key": "X-Content-Type-Options",
          "value": "nosniff"
        }
      ]
    }
  ]
}

Redirects and Rewrites

Configure in Render static site settings:

{
  "redirects": [
    {
      "source": "/old-path",
      "destination": "/new-path",
      "permanent": true
    }
  ]
}

Troubleshooting Common Issues

SSL Certificate Not Issuing

Wait longer: DNS propagation can take up to 24 hours
Check DNS records: Ensure CNAME records are correct
Verify domain in Render: Check domain status in dashboard
Contact support: Render support is responsive and helpful

Mixed Content Warnings

Ensure all resources (images, scripts) load via HTTPS
Update internal links to use https://
Check browser console for specific warnings

Domain Not Resolving

Verify CNAME records in Namecheap
Check for typos in domain configuration
Use DNS lookup tools to verify propagation

Best Practices for Optimal Performance

1. Enable Caching

Leverage Render's built-in CDN for static assets:

Set appropriate cache headers
Use versioned filenames for long-term caching

2. Optimize Assets

Compress images before uploading
Minify CSS and JavaScript
Use modern image formats (WebP)

3. Monitor Performance

Use Render's built-in metrics
Integrate with monitoring services
Set up alerts for downtime

4. Implement Backups

Regular database backups (if applicable)
Version control for all code changes
Environment backups in Render

Render Free Tier Limitations

While Render offers an excellent free tier, be aware of its limits:

Web Services: 750 hours/month (enough for one always-on service)
Static Sites: Unlimited with fair usage
Bandwidth: Generous free allowance
Build Minutes: 500 free minutes/month

For most personal projects and small businesses, these limits are more than sufficient.

Conclusion

Hosting your Namecheap domain with Render provides a powerful, secure, and cost-effective solution for your web presence. The automatic SSL certificate provisioning eliminates a major pain point for website owners, while Render's global infrastructure ensures fast, reliable performance.

Whether you're building a simple portfolio, a business website, or a complex web application, this combination offers the perfect balance of simplicity and power. The setup process is straightforward, and once configured, your site will run smoothly with minimal maintenance required.

Ready to get started? Head over to render.com and deploy your first project today!

Forem: Codespear

How to Remove All Git Commits Locally Without Losing Your Code

## Why Remove Git History?

Method 1: Remove Git Completely (Keep Only Your Code)

Step 1: Delete the .git directory

Method 2: Reset Git and Start a Fresh Repo

Step 1: Delete the Git history

Step 2: Reinitialize a new Git repository

Step 3: Add all your existing files

Step 4: Create the first clean commit

Optional: Reconnect to a Remote Repository

Final Thoughts

🧹 How to Clear Cache in Windows Using PowerShell (Complete Guide)

🔴 Why Clear Cache in Windows?

🟦 PowerShell vs CMD — What’s the Difference?

🧹 1. Clear User Temporary Files

🧹 2. Clear Windows Temp Folder

🧼 3. Flush DNS Cache

🧹 4. Clear Windows Prefetch Cache

🧹 5. Clear Thumbnail Cache

🧼 6. Reset Microsoft Store Cache

🟩 Combined PowerShell Script (Run All at Once)

🎯 Final Thoughts

How to Connect Your Namecheap Domain to a Render App (Step-by-Step Guide)

🔧 Step 1: Add Your Custom Domain in Render

🌐 Step 2: Configure DNS Records in Namecheap

For your main/root domain (example.com):

For the www subdomain (www.example.com):

🔒 Step 3: Enable HTTPS on Render

🧪 Step 4: Test Your Domain

🔍 Bonus Tips

Check DNS Propagation

Choose between root or www

🎉 Final Thoughts

🔥 How to Generate a JKS Keystore Without Android Studio (Complete Guide)

A simple tutorial for creating a .jks file using Keytool — with fixed passwords, alias, and automated command

1. The Goal (What We Want to Generate)

2. Checking If keytool Works

3. Install the Java Development Kit (JDK)

4. Add JDK to PATH (Windows)

Steps:

5. Generate the JKS File (Non-Interactive Command)

6. Verify the Keystore

7. Create a key.properties File (Android)

key.properties

8. Example build.gradle Signing Setup

Final Thoughts

📦 Managing Multiple Projects in One Repository: Submodules, Subtrees, Monorepos & Partial Cloning Explained

🔧 1. Git Submodules — Independent Projects Inside a Parent Repository

✔ When to Use Submodules

📌 Example Use Case

📥 Adding a Submodule

▶ Initialize & Update Submodules

🔄 Working Inside a Submodule

💡 Pros

⚠ Limitations

🌳 2. Git Subtrees — Embed Projects Without Complexity

✔ When to Use Subtrees

📌 Example Use Case

➕ Add a Subtree

🔄 Updating the Subtree

💡 Pros

⚠ Limitations

🏢 3. Monorepos — A Single Repo for Multiple Projects

✔ When to Use a Monorepo

📁 Example Monorepo Structure:

💡 Pros

⚠ Limitations

📥 4. Partial Cloning — Clone Only the Project You Need

✔ When to Use Sparse-Checkout / Partial Cloning

📌 Example Setup

🧩 Clone Repo Without Checkout

🔧 Initialize Sparse Checkout

▶ Checkout Files

💡 Pros

⚠ Limitations

🎯 Which Approach Should You Choose?

🚀 Final Thoughts

How to Install Node.js and Android Development Tools on a Custom Drive in Windows

Introduction

Step 1: Delete the `.git` directory

For your main/root domain (`example.com`):

For the `www` subdomain (`www.example.com`):

A simple tutorial for creating a `.jks` file using Keytool — with fixed passwords, alias, and automated command

2. Checking If `keytool` Works

`key.properties`

8. Example `build.gradle` Signing Setup

Solution 1: You Have a `master` Branch Instead