Forem: Pawinphat Charoenrat

Git Full Speed Ahead Part 4 : TIP 1 # Updating Git Bash on Windows

Pawinphat Charoenrat — Sat, 31 Jan 2026 07:31:13 +0000

Git Bash is a favorite tool for a lot of Windows developers. It lets us enjoy a Unix-like shell without having to leave Windows behind.

The catch is… many of us keep using Git Bash for ages and completely forget to update it. That’s usually when strange, hard-to-track bugs start popping up.

In this article, we’ll walk through how to update Git Bash on Windows the right way—safe, simple, and without messing up your existing environment.

✨ Check your current Git Bash version first

Before updating anything, it’s a good idea to check which version you’re currently using.

Open Git Bash and run this command:

git --version

Note (Jan 2026): The latest Git version is 2.52.
If you’re seeing a much older version (for example, something that’s months or even years behind), it’s a good idea to update right away. Git gets bug fixes and security patches on a regular basis, so staying up to date really matters.

🎯 Updating Git Bash from Git Bash (if the updater is available)

Newer versions of Git for Windows come with a built-in updater.

In Git Bash, run:

git update-git-for-windows

After running the update command, one of two things will happen:

1. A newer version is available
Git Bash will show a message saying something like “Download and install Git” and ask for confirmation.
Type Y, and the update process will start automatically.

2. You’re already on the latest version
Git will let you know that everything is up to date, and there’s nothing else you need to do.

🎰 Keeping Git Bash up to date might feel like a small, boring task—but it can save you from a surprising amount of pain later. Many strange bugs, unexpected behaviors, or security issues come from running an outdated Git version without realizing it.

The good news is that updating Git Bash on Windows is usually quick and safe, especially if you use the built-in updater. Make it a habit to check your Git version every once in a while. Your future self (and your teammates) will thank you.

Sometimes, the best debugging tool is simply… staying up to date.

From Zero to WordPress: Build Your Site Locally with LocalWP – Part 1

Pawinphat Charoenrat — Tue, 02 Sep 2025 08:25:04 +0000

When people first start building a website, they often run into the same wall: Where do I even begin? Writing code from scratch feels intimidating, but relying on a website builder can feel limiting. Many end up stuck in between—the desire to create something online versus the technical hurdles that seem to block the way.

This is where WordPress changes the game. It began as a simple blogging platform, but over time it has grown into one of the most powerful and flexible website-building tools in the world. Today, more than 40% of all websites on the internet are powered by WordPress.

But what if you want to experiment with WordPress without spending money on real hosting or risking mistakes on a live site? That’s where LocalWP comes in. It lets you set up WordPress locally on your own computer—safe, fast, and surprisingly fun.

📌 Install LocalWP

1. Download LocalWP from Localwp

2. Install it on your computer

3. After Installing

4. LocalWP Dashboard

💻 Basic Setup of LocalWP

1. Go to your Profile
2. Select Preferences

3. Configure the settings as desired in Appearance and Behavior

4. Select “Log in to Local”

5. After selecting “Log in to Local,” the application will open your browser. If this is your first time, choose “Create an Account.” If you already have an account, you can simply log in.

6. Fill in all the required information and click “Create Your Account.”

🎯 Creating a New Site

1. Click “Create a New Site” or press the plus (+) button

2. Insert your site's name and click Continue

3. Select your preferred environment and click Continue

4. Set up WordPress and click “Add Site.” It’s recommended to open the Advanced Options and choose your preferred language as well.

5. LocalWP is downloading WordPress…

6. Once the site has been created, this window will appear

🔦 Deleting a Site

Right-click on the site name, scroll down, and click Delete.

A confirmation dialog will appear

🎐 Launch LocalWP & Start Building with WordPress

1. Open the app named Local

2. The LocalWP app has the following overview:

2.1 Number 1: The site name you want to develop with WordPress
2.2 Number 2: Access the WordPress Admin panel via your browser
2.3 Number 3: Open the site in your browser
2.4 Number 4: Start the site
2.5 Number 5: Site host

3. Once the site is started, you can notice that it’s running as shown in the image.

4. Try opening WordPress by clicking on Number 3 or by typing the URL from Number 5 into your browser’s address bar.

And that’s a wrap on getting started with LocalWP! You now have a safe, local playground to experiment with WordPress without worrying about breaking anything online.

In Part 2, we’ll dive into WordPress itself—exploring themes, plugins, and tips to help you build your very first fully functional website. Stay tuned, because this is where the fun really begins!

Git Full Speed Ahead Part 3: Git Remote Repositories: Push, Pull, and Collaborate Easily

Pawinphat Charoenrat — Mon, 18 Aug 2025 12:12:24 +0000

Table of content

What is a Git Branch?
Basic Git Branch Commands
Creating a New Branch
Switching Branches
Merging a Branch into the Main Branch
Deleting a Branch
Understanding git push in Depth
Creating a PAT (Personal Access Token)
Working with Remote Repositories in Git
Step 1: Configuring a remote
Step 2: Pulling and cloning repositories
Step 3: Pushing changes to remote
Removing or updating a remote config
Renaming a Branch
GIT FETCH

🪴 What is a Git Branch?

In version control systems like Git, a branch is a separate line of development. It allows you to work on new features or bug fixes independently, without affecting the main codebase (usually main or master).

Think of Git as a map of your project, where each branch is a different route you can take. For example:

main (or master) → The stable code, ready for production
feature/login → Developing a login system
bugfix/header → Fixing a header display issue

Branches let you experiment safely, collaborate with teammates, and keep the codebase organized. They’re a core concept in Git that make development smoother and more predictable.

✅ Benefits of Git Branches

Parallel Development: Multiple developers can work on different features at the same time.
Risk Isolation: Changes are made on separate branches, so the main branch remains safe from accidental issues.
Easy Cleanup: If a branch introduces problems, it can simply be deleted without affecting the main codebase.

Understanding Git Branches in One Picture 🧠

When we start a new project with git init and follow it with git add and git commit, we get an initial branch called main (or master, depending on the Git version).

In this diagram, each circle represents a commit we’ve made, and the lines show the path of the main branch.

📌 Two key points in the diagram:

Before the commit named main 1.1, a branch called bugfix was created to fix a bug. It was later merged back into main at main 4.1.

After main 1.1, another branch called feature was created to work on new developments. This branch hasn’t been merged back yet (it’s still separate).

This is one of Git’s superpowers: it allows us to work on multiple things simultaneously without mixing them together. You can develop new features, fix bugs, or even experiment on a temporary branch, all safely 🤓.

“Think of it like taking a side road: you go fix something, and then come back to the main road — Git makes this simple and safe.”

🧬 Git Branch Inheritance: Step by Step

What Happens:
Branch main
This is the starting point. All commits, the staging area, and the working directory contain only the data from main.

Branch feature-1
When we create this branch from main, it gets a “snapshot” of the latest state of main at that moment.
This means commits, the staging area, and the working directory include everything from main plus any changes made in feature-1.

Branch feature-2
This branch is created from feature-1, so it inherits everything from main + feature-1, and adds only the changes specific to feature-2.

How Are the Different Parts of Git Separated?

Git Component	Meaning in This Context
commit	A recorded snapshot saved in Git’s database (git commit).
staging area	Changes prepared for the next commit (git add places them here).
working directory	The actual files you see in your project folder right now (may not be committed or staged yet).
Ref (HEAD/heads)	A pointer to the latest position of each branch.

So, when feature-2 is created from feature-1, it’s like Git saying:
“Okay, I’ll start a new branch and copy over the latest state of feature-1 — including commits, the staging area, and the working directory — so you can continue working from there.”

🔁 Common Misconception:

“For example, if the main branch gets a new commit, it will automatically affect all branches created from it.”

✅ The Truth:

A new commit on one branch does not affect any other branch.

(This applies to main, feature, or any branch.)

Changes only propagate if you explicitly merge or rebase onto another branch.

🧪 Visual Comparison:

Creating a branch is like copying a friend’s notebook and writing in your own copy.
If your friend writes 10 more pages, your notebook doesn’t change — unless you decide to copy those pages again.

💻 Basic Git Branch Commands

Listing Branches
This command shows all the Git branches you have created.

git branch

git branch lists all branches and marks the current branch with an asterisk (*).

✏️ Creating a New Branch

This command is used to create a new branch.

git branch <branch-name>

Use this command to create a new branch with the specified name.

❌ Branch Naming Rules (Must Avoid or Strongly Discouraged)

1. Do not use names that conflict with Git references
Examples: HEAD, FETCH_HEAD, ORIG_HEAD, MERGE_HEAD, index

2. Do not use spaces
Example: feature new login → ✅ feature-new-login or feature/new-login

3. Do not start or end with /
Example : /feature/login, feature/ → ✅ feature/login

4. Do not use .. (two consecutive dots)
Example: feature..bugfix

5. Do not use @{}
Example: fix@{bug}

6. Avoid certain special characters
Example: ~, ^, :, ?, [, \

7. Do not name a branch the same as a tag

♻️ Switching Branches

git switch <branch-name>

Use this when you want to switch and start working on a different branch.

TIP

You can combine creating a new branch and switching to it in a single command:

git switch -c <branch-name>

⚡ Merging a Branch into the Main Branch

Git merge is a fundamental command in Git that allows you to combine the development histories of two or more branches into a single branch. It is a key part of collaborative workflows, as it enables developers to integrate new features and bug fixes from a feature branch into the main branch of a project without losing any work.

git merge <branch-name>

In the example above, I added an option file in the ABC branch. When merging the ABC branch into main, Git shows the changes, and using git log reveals that the commit history from the ABC branch has also been included.

📛 Deleting a Branch

You can remove a branch that is no longer needed using the following command.

git branch -d <branch-name>

⚠️ Caution

git branch -d and git branch -D are not the same.

✅ git branch -d – Safe delete

Deletes the branch only if it has been fully merged into your current branch (e.g., main).
Prevents you from losing any unmerged work.
Git will show an error if the branch hasn’t been merged yet.

⚠️ git branch -D – Force delete

Forces deletion even if the branch hasn’t been merged.
Can accidentally delete work that hasn’t been merged yet.
No safety checks are performed—you might lose unmerged changes.
Equivalent to git branch --delete --force.

🚀 Understanding git push in Depth

Have you ever wondered... after finishing work on your local machine, how do you make your code appear on GitHub? The answer is git push!

In this article, we’ll dive into what the git push command is, how it works, and the key things you should know to use Git with more confidence 💪

🔼 What is git push?

git push is the command used to push your code from your local machine to a remote repository (such as GitHub, GitLab, or Bitbucket).

💡 Benefits of git push

1. ✅ Backing Up Code

Keeps your code safe even if your computer is damaged.
A copy of your code lives on GitHub or another remote.

2. 👥 Team Collaboration

Team members can pull (git pull) the latest code from the remote to continue working.
Prevents duplicate or conflicting code.

3. 📜 Change History

Every push records the current state of your project.
Makes it easy to roll back or restore a previous version.

4. 🌍 Sharing Code

Share your code with others for viewing or review.
Handy for submitting work via a GitHub link.

5. 🚀 Automatic Deployment

Some systems (like Vercel, Netlify, or CI/CD pipelines) automatically deploy your project whenever you push.

🔁 Quick Recap: Local vs Remote

git commit → Saves your changes locally on your machine
git push → Sends those changes to the server

Explaining the Diagram

1. Starting Point: Synchronized

The Local Repository (on your computer) and the Remote Repository (on the server) contain the same code, because you’ve already pushed.

2. While Working: Unsynchronized

You create Commit 2 locally, then continue working and create Commit 3.
At this point, the Local repository is two commits ahead of the Remote, but nothing has been pushed yet.

3. Ending Point: Synchronized Again

When you’re ready, you can push once to send both Commit 2 and Commit 3 to the Remote.
Now the Local and Remote repositories are back in sync.

A single push can send all pending commits at once—there’s no need to push after every commit.

📌 Creating a PAT (Personal Access Token)

1. You need to have a repository on GitHub. If you don’t have one yet, see Part 1.
2. You’ll need to prepare a PAT by following these steps:
3. Go to GitHub, click on your profile in the top-right corner, and select Settings.

4. Go to the Developer settings section on the left-hand side.

5. Click on Personal access tokens, where you’ll see two options: fine-grained tokens and classic.

📭 Note

Classic PATs → Provide very broad access across personal and organizational repositories. If the key is leaked, the risk is high.

Fine-grained Tokens → Allow more precise control, such as limiting access to specific repositories or granting permissions by category (e.g., read/write issues, code). This reduces potential damage if the key is leaked and is better suited for high-security needs.

In my example, I chose Fine-grained tokens and clicked Generate new token.

7. Enter the details
* Token name – Give your token a recognizable name
* Description – Add optional details about the token’s purpose
* Owner – Select the account that will own the token
* Expiration date – Set when the token should expire
* Repository access – Choose which repositories the token can access

Public repositories → The token can only access public repos. Ideal if you just need to fetch open-source code or run automation without touching your private repos.

All repositories → The token can access all repos you have permission for, both public and private. This gives full access but carries higher risk if the token is exposed.

Only select repositories → The token can only access specific repos you choose when creating it. Best for limiting scope to a single project or targeted automation.

8. Set the necessary permissions – For example, set Contents to Read and Write.

8.1 Make sure the permissions match the task you need.
8.2 Incorrect settings may cause the token not to work or reduce security.
8.3 Once configured, click Generate Token.

9. Copy the PAT and store it somewhere safe.

📡 Working with Remote Repositories in Git

When working with Git, you usually start with a local repository on your machine. But to collaborate with others or back up your code, you’ll need to connect it to a remote repository (such as GitHub, GitLab, or Bitbucket).

🛠️ Step 1: Configuring a remote

1. After making your commits and preparing to push to a repository for the first time, use the following command:

git branch -M main

2. Next, check whether the repository URL has been configured using this command:

้git remote -v

If the command returns the repository name, you can skip steps 3–4. If it returns nothing or prompts for a new input, follow steps 3–4.

3. Go to the GitHub website, navigate to Profile > Your repositories, and select the repository you want.

4. Copy the repository's URL.

4.1 If you’re working in a team or joining an existing project where the repository already has commits, the process to copy the URL is slightly different: go to Code and copy the repository URL from there.

Once you have the repository URL, use the following command:

git remote add origin <url repository>

Example

🔄 Step 2: Pulling and cloning repositories

🌀 Git Clone

The git clone command is used to copy a project from a remote repository to your local machine.
It brings over everything — branches, commits, files, and folders — so you can start working with the project locally.

This command is typically used in the following cases:

When you’re joining a development team that already has a remote repository.
When you want to fork a repository and work on your own copy.
When you need to clone a template repository to start a new project.

👉 In short, git clone is usually the first command you run when getting a project from a remote server.
After cloning, you’ll use other commands like git pull to keep your local copy up to date.

git clone command

    git clone <repository-url>

📜 Note

When you use git clone, there’s no need to run git init — the repository is already initialized for you.

📟 Git PULL

git pull is the command used to update your local Git repository with the latest changes from the remote repository.
It essentially combines two commands in one: git fetch + git merge.

Make sure you are on the branch you want to pull. For example, if you want to pull updates from the main branch, switch to main first.
Run the git pull command.

git pull

This table shows what happens when you run git pull, depending on whether your local branch is behind or up-to-date with the remote. It’s a quick reference for expected results and potential conflicts.

Local vs Remote State	Merge Direction in `git pull`	What Happens	Common Outcome	Notes
Local is older than remote	Remote → Local	Remote commits are merged (or fast-forwarded) into your local branch.	Local branch moves forward to match remote.	No conflicts unless overlapping changes exist.
Local is equal to remote	No merge	Nothing to merge — histories are identical.	“Already up to date.”	Working tree stays the same.
Local is newer than remote	Remote → Local	Git fetches remote, but since it’s behind, merge usually does nothing.	Local branch unchanged; remote stays behind until `git push`.	Merge step may be skipped entirely if there are no remote changes.
Local and remote have diverged	Remote → Local	Remote commits and local commits are merged together.	Merge commit created (or rebase if using `-rebase`).	Can cause merge conflicts; both histories are preserved.

🚀 Step 3: Pushing changes to remote

🌈 GIT PUSH

The push command sends your local changes to the remote repository.

git push -u origin <branch>

Example

git push -u origin main

This command means: send all changes from the local main branch to the remote repository named origin.

1. When using git push, Git will prompt you to enter a password or token via a sign-in window (in this example, a token was used).

1.1 Select Token.
1.2 Enter your PAT in the input field (refer to the “Creating a PAT” section).

2. Once the token is entered correctly, the local data will be successfully pushed to the remote repository.

✳️ Pushing All Branches

Previously, we pushed branches one at a time. If you have multiple branches, that means repeating the push process for each branch separately.

Instead, if you want to push all branches at once in a single command, you can use:

git push --all

🔦 Commands for managing your remote and local branches:

🗑️ Removing or updating a remote config

If you want to remove or update the configuration of a remote connection, you can do so with the following command:

git remote rm origin

The command git remote rm origin is used to remove the connection between your local Git repository and the remote repository named origin.
This removal does not delete the repository on GitHub; it only disconnects the link from your local machine. All files and history on GitHub remain intact.

✒️ Renaming a Branch

If you mistyped a branch name or want to change it, use this command.

git branch -m <old-branch-name> <new-branch-name>

Example

🎯 GIT FETCH

Understanding git fetch

When you run git fetch, Git checks the remote repository (like GitHub) for new commits, branches, and tags. It downloads these new items and stores them in your local repository as remote-tracking branches (e.g., origin/main). Your local working files and branches remain untouched.

git fetch

From this example, let's say someone else has updated the main branch on the remote repository.

Initially, if you run git status, it might report that your local branch is "up to date" because it's only checking its internal data, which doesn't know about the new remote changes yet.

When you run git fetch, Git downloads those new changes. Although git fetch itself often doesn't produce a clear output, your local repository now has the new data.

To see the result of the git fetch, you can then run git status again. It will now report that your local main branch is behind the origin/main branch. This is the explicit "report" you were looking for.

If you were to make changes and push to main without updating first, your changes would be rejected by the remote repository. This is a safety feature to prevent you from accidentally overwriting the updates from your teammates. To fix this, you would need to use git pull to first merge the remote changes into your local branch before pushing again.

✒️ Note
If you’ve already run git fetch before, running it again may not show any new downloads — but that doesn’t necessarily mean your local repository is fully up to date with the remote. It’s recommended to run git status to verify the current state.

💡 Best Practice with git fetch

Run git fetch before git status to check if you’re behind the remote.
Always run git fetch before git push to avoid conflicts.

Remember: Running git fetch twice in a row might not show new output — it simply means nothing has changed remotely since the last fetch.

Command	What it does	When to use
git fetch	Downloads new data from remote but doesn’t change local files	Safe check for updates
git pull	Downloads and merges remote changes into local branch	When you’re ready to update your branch

🏁 Wrapping Up

We’ve covered the core Git commands for working with remotes — from cloning and pulling to pushing and managing configs.

Keep practicing these commands, and soon collaborating with Git will feel second nature. 🚀

Screen Sharing 101: How to Use Miracast to Mirror Android to PC Without Third-Party Software

Pawinphat Charoenrat — Mon, 04 Aug 2025 07:20:36 +0000

I had a need to mirror my Android screen to my computer, and I found a really convenient way to do it — using Wireless Display, a built-in feature included for free in Windows.

This method allows you to share your mobile screen with your PC without using any third-party apps.

1. What Is Miracast?

Miracast is a wireless technology that allows you to transmit both video and audio from one device to another via Wi-Fi Direct — no HDMI cables or additional apps required. Often referred to as “wireless HDMI”, Miracast supports high-resolution streaming, including 1080p and even 4K, depending on your hardware capabilities.

2. How It Works

Topology Details

1. 🟠 Wi-Fi Direct (P2P / Ad-hoc)
The phone creates or connects via Wi-Fi Direct directly to the target device (TV, Laptop)

No router or access point (AP) is required

Temporarily disconnects the phone from its current Wi-Fi

This is the classic Miracast mode (defined by the Wi-Fi Alliance standard)

✅ Pros: Works even without an internet connection
❌ Cons: You can't use the internet on your phone while casting

2. 🟢 Infrastructure-based Miracast
Both the phone and the target device connect to the same Wi-Fi network via an access point (AP)

Uses TCP/UDP or Multicast within the local network

Only works with devices that support "casting over network" (e.g., Windows 10/11, some Android devices)

✅ Pros: Internet remains accessible; can be more stable in some cases
❌ Cons: Requires a Wi-Fi router (AP); not all devices support this mode

Topology	Requires Wi-Fi Router?	Internet Usable While Casting?	Stability
Wi-Fi Direct	❌ No	❌ No	✅ Moderate
Infrastructure	✅ Yes	✅ Yes	✅ Higher (if Wi-Fi is strong)

🔧 Devices in a Miracast Setup

1. Sender (Source / Transmitter)
The device that sends video and audio signals wirelessly to a receiving device via Miracast.

Examples:

Android smartphones
Android tablets
Windows 10/11 laptops or PCs (can cast to other displays)
Media devices like Microsoft Surface

Responsibilities:

Encode video/audio signals in real time
Transmit the signal via Wi-Fi Direct to the Receiver
Can operate in point-to-point or infrastructure (router-based) mode

2. Receiver (Sink / Display)
The device that receives and renders the stream coming from the Sender.

Examples:

Smart TVs with built-in Miracast support
Windows 10/11 PCs/laptops (with "Projecting to this PC" enabled)
Miracast dongles, such as the Microsoft Wireless Display Adapter
Some Android TV boxes that support acting as a Miracast Receiver
Responsibilities:
Receive the stream from the Sender
Decode video and audio
Render output on the screen

3. Optional Network Devices (Not Required, but Helpful)
While Miracast is designed to work peer-to-peer over Wi-Fi Direct — without a router — in practice, many devices are often connected to the same Wi-Fi network for convenience and reliability.

Examples:

Wi-Fi Router: Makes device discovery easier
Access Point / Mobile Hotspot: Acts as a central hub for network communication

💡 Note: These devices are not part of the Miracast standard itself, but they can improve stability, compatibility, and ease of device discovery during casting.

🧰 Preparing Your PC Before You Start

Before using Miracast, you’ll want to check whether your computer supports receiving a wireless display.

Follow these steps:

1. Press Windows key + R to open the Run dialog box

2. Type dxdiag and hit Enter

dxdiag

3. In the DirectX Diagnostic Tool window, click "Save All Information..."

4. Open the saved .txt file and search for "Miracast"
5. Look for a line like this:

Miracast: Available, with HDCP

Understanding Your Miracast Status

After checking the dxdiag report, you may see one of the following Miracast status lines:

5.1 Miracast: Available, with HDCP

This means your hardware fully supports Miracast, including HDCP (High-bandwidth Digital Content Protection), which is required for streaming protected content like Netflix or Hulu.

5.2 Miracast: Available, no HDCP

Your hardware supports Miracast, but does not support HDCP. This means you may not be able to stream DRM-protected content, but general screen mirroring should still work fine for most use cases (e.g., presentations, app demos, etc.).

5.3 Miracast: Not Available

Your PC’s hardware (either the graphics card, Wi-Fi adapter, or both) does not support Miracast. Unfortunately, you won’t be able to use Miracast features unless you upgrade or switch devices.

6. If Your Hardware Supports Miracast

Open Command Prompt by right-clicking on it and selecting “Run as administrator.”

7. Type

DISM /Online /Add-Capability /CapabilityName:App.WirelessDisplay.Connect~~~~0.0.1.0

Windows will connect to the update servers and begin downloading the required components for Wireless Display.

🕐 This process may take a few minutes, and you'll see a progress percentage as it completes.

Once finished, your PC will be ready to act as a Miracast receiver using the built-in "Projecting to this PC" feature.

8. Once the installation is complete, you should see a message indicating that the operation was successful.

9. Restart your computer to finalize the installation.

🔌 Basic Usage: Getting Started with Miracast

In this setup, we’ll use the Infrastructure Mode — meaning both devices are connected through an Access Point (AP) (e.g., your Wi-Fi router).

🧰 Devices You’ll Need:

An Android smartphone with Wi-Fi turned on and connected to the AP
A Windows PC (Windows 10 or newer) with Wi-Fi enabled and connected to the same AP
Both devices must be connected to the same Wi-Fi network (same AP) This allows them to discover each other and communicate over the local network using Miracast.

🖥️ Enabling Wireless Display on Windows (Receiver Mode)

To allow your Windows PC to receive screen mirroring via Miracast:

1. Go to Settings > System > Projecting to this PC

2. Under “Some Windows and Android devices can project to this PC”, the default setting is “Always Off (Recommended)” — this is for security purposes.

To enable Miracast receiving, change it to either:

"Available everywhere" — for open access
"Available everywhere on secure networks" — recommended if you're on a trusted Wi-Fi network

🔑 Optionally adjust the following settings:

Require PIN for pairing
Ask for permission every time a device tries to project

⚠️ Note:

Be cautious when enabling this feature, especially on public or shared networks. For most home users, “Available everywhere on secure networks” is a good balance of convenience and safety.

📡 Start Receiving a Cast from Your Android Device

To begin receiving a screen cast from your phone:

Go to Search on your Windows taskbar

Type "wireless display" and open the wireless display app (this is the Wireless Display receiver)

Your PC will now be discoverable by your Android device when casting.

💡 Make sure the Wireless Display feature is installed and enabled. If not, refer to the installation steps above.

3. Open the “Wireless Display” app in Sink mode to wait for a cast from your mobile device.

Screen Casting from a Smartphone (Android)

Settings may vary by device. Use the following steps as a general guideline and adapt them to your own smartphone.

1. Open the status menu (swipe down from the top of the screen) and tap on the Cast option.

2. Tap this button to start casting from your phone.

3. Tap the name of the PC or laptop you want to share your screen to.

After completing the steps on your Android phone and PC or laptop, you should see the following:

🔚 How to Stop Casting

On your Android device, open the status menu and tap the Cast icon again to disconnect.

👉 Note
In the Wireless Display window on your PC, move your mouse to the fullscreen icon (as shown in the image) to switch to fullscreen mode.
To exit fullscreen, move your mouse to the edge of the screen — a control bar will appear (as shown). Click the exit fullscreen button.

🔄 Additional Info

If you want your computer to act as the source and cast its screen to a Smart TV or other wireless display:
Go to Settings > System > Display > Multiple displays > Connect to a wireless display,
or simply press Windows key + K.

⚠️ Important: A computer cannot act as both a source and a sink at the same time. You must choose one role.

✅ Wrapping Up

Miracast is a powerful yet often overlooked feature that lets you wirelessly share your screen without the need for third-party apps. Whether you're presenting, streaming, or just want a bigger display, setting it up takes just a few steps on supported devices.

Give it a try — and enjoy the freedom of wireless screen sharing!

Git Full Speed Ahead Part 2: Organize Your Git Projects: Local Workflow Made Simple

Pawinphat Charoenrat — Tue, 22 Jul 2025 12:33:52 +0000

Overview

In this section, we’ll explore the typical local Git workflow — a series of commands and steps developers follow to manage code efficiently. Understanding the workflow helps you keep your project organized, track changes systematically, and collaborate smoothly with others (even when working solo!).

Whether you're just getting started or brushing up on Git fundamentals, a solid grasp of this flow will lay the groundwork for everything to come.

Table of content

GIT WORKFLOW
GIT INIT
GIT STATUS
GIT ADD
GIT RM -- CACHED
GIT COMMIT
GIT LOG
GIT RESTORE

GIT WORKFLOW

What Happens When You Run a Git Command

Git Workflow Overview
Here’s a quick summary of the basic Git workflow:

1. Working Directory
Start with a regular folder. Run git init to begin tracking the project with Git.

2. Untracked Files
Git sees your files but doesn't track them yet. You need to run git add to include them in version control.

3. Staging (Tracked Files)
Files you add are moved to the staging area, where Git prepares them for a commit.

4. Commit
git commit saves a snapshot of staged changes to your local repository.

5.Push to Remote
git push uploads your commits to a remote server — useful for backup or collaboration.

🧪💻 I ran the test using Git Bash, and I'm working on Windows.

🔥 GIT INIT

When starting with Git for the first time in a project, this is the command you'll need:

git init

This initializes a new Git repository in your current directory. It sets up the .git folder, allowing Git to begin tracking changes in your project.

🔥 GIT STATUS

One of the most essential Git commands — git status helps you quickly and clearly see what’s going on in your project.

📌 What does git status do?
The git status command displays the current state of your Git repository. It shows you:

Files that have been modified
Changes that are not yet staged
Files that are in the staging area (ready to commit)
Untracked files — files that Git sees but isn't tracking yet
The current branch name, and how it's related to the remote (e.g., ahead/behind)

It’s the first command you’ll often run before committing — like checking your dashboard before moving forward.

git status

Example of git status command output

🔍 Breaking Down the git status Output

1. On branch main
This tells you exactly which branch you’re currently working on — in this case, main. Knowing your branch keeps your workflow on track.

2. Untracked files:
These are brand-new files Git has spotted but isn’t tracking yet. They’re not staged, so Git’s basically saying, “Hey, did you want me to watch these?”

3. File names below this section
These are the actual files waiting in the wings — ready to be added to the staging area when you run git add.

📂 File Statuses in Git (via git status)

File Status	Description	How to Handle
Untracked	New files not being tracked by Git	`git add <file>` to start tracking them
Tracked - Unmodified	File is being tracked and hasn't changed since last commit	✅ No action needed
Modified	File has been changed but not yet staged	`git add <file>` to stage, or `git restore <file>` to discard
Staged (Index)	Changes have been staged and are ready to be committed	`git commit` to save the changes
Deleted (staged)	A file has been deleted and the deletion has been staged	`git commit` to record the deletion
Deleted (unstaged)	A file has been deleted but the deletion is not staged	`git add <file>` to stage deletion or restore it
Renamed	Git detects a file has been renamed (after staging)	`git commit` to save the rename
Conflicted	Merge conflict: Git can't automatically merge changes	Manually resolve, then `git add <file>`
Ignored	Files intentionally excluded via `.gitignore`	✅ No action needed (unless misconfigured)

💡Summary
The git status command is your go-to tool for checking what’s going on in your working directory. It shows which files have been modified, newly added, or are ready to commit. It’s an essential habit to run git status before every commit or push --helping you stay in control and avoid mistakes.

🔥 GIT ADD

📌 What is git add?

git add is the command used to move changes into the staging area, which is the step right before committing those changes into your Git repository.

✨The staging area is a temporary space where you collect the changes you intend to include in your next commit.

✅ Using git add

To stage a specific file, use:

git add <filename>

This adds only the specified file to the staging area, preparing it to be committed.

✅ To stage all changes (including new and modified files) in the current directory and its subdirectories, use:

git add .

Stages all changes in the current directory and its subdirectories — including new and modified files.

✅ Use this to stage only files with a specific extension (e.g., .js, .txt, etc.)

git add *.<extension>

✅ To stage only tracked files — files that Git has seen before — use:

git add -u

The -u flag tells Git to update the index with changes to tracked files only (modified or deleted), skipping any new untracked files.

Examples of Using git add

🔥 GIT RM --CACHED

📌 What is git rm --cached?

The git rm --cached command is used to remove a file from the staging area (also called the index) without deleting the file from your local machine. This means the file will no longer be included in the next commit, but it still physically exists in your project folder.

✨ Use this when you want Git to stop tracking a file (untrack it), but you don’t want to actually delete the file.

🧭 Command Syntax
✅ This command removes a file from the staging area one at a time:

git rm --cached <filename>

✅ You can use this command to remove an entire folder from the staging area:

git rm --cached -r <foldername>

✅ Unstage All Files and Folders from the Git Index
The following command will unstage all files and folders in the current directory and all subdirectories from the Git index:

git rm --cached -r .

In summary: This command removes all tracked files—meaning it untracks everything under your project root.

This command removes all tracked files except those explicitly excluded via your .gitignore file.

🧠 Why Use git rm --cached?

You accidentally added or committed files that should be ignored
You want Git to stop tracking files without deleting them from your local disk
To work with .gitignore so that files won’t be tracked in the future

⚠️ Caution
The files remain on your computer but are removed from Git tracking

If you use git rm without --cached, the files will be deleted both from the staging area and your local machine!

Command	Result
git rm filename	Removes the file from Git and deletes it locally
git rm --cached file	Removes the file from Git but keeps it on your disk

Example of using the git rm command

Brief Explanation of How It Works

When you run git status for the first time, you will see that all files and folders have been added to the staging area.
Use the command git rm --cached -r dist/ (important: don’t forget the -r !)
Run git status again, and you will notice the dist folder is now marked as Untracked.

🔥 GIT COMMIT

📌 What is git commit?

The git commit command is one of the core Git commands used to save changes in your project to the repository. Git stores these changes as a "snapshot" of your files, allowing you to review or revert to them later.

✅ Using git commit

Before you can run git commit, you need to tell Git which files you want to include by using git add.

git commit -m "Add a message describing the changes here"

Use the command git commit -m "Add a message describing the changes here" to create a commit with a message explaining your changes.

🧠 Other Related Commands
Use this to commit all changes in tracked files without needing to run git add.

git commit -a -m "message"

Use git commit -a -m "message" to commit all changes to tracked files with a commit message, without needing to run git add first.

example of git commit

🔥 GIT LOG

📌 What is git log?

The git log command is used to show the commit history of your repository. It displays important information about each commit, such as:

Commit id (SHA-1 hash)
Author name
Commit date
Commit message

✅ Using git log

git log

This command displays all commits, ordered from the most recent to the oldest.

Example of git log

commit 69c4808ce89cd63b55e3d01c862xxxxxx (HEAD -> main)
Author: Pawinphat <xyz@e-mail.com>
Date:   Tue Jul 22 13:47:43 2025 +0700

    Head 1 : Add all files and folder

The commit ID is stored as a 40-character SHA-1 hash.
The name of the person who made the commit.
The date when the commit was made.
The commit message.

Useful git log options

Show commits in a concise (short) format.

git log --oneline

Show history for a specific file
Use this to see which commits have modified that file.

git log <filename>

Example

git log ABC.txt

-Show commits along with a branch structure graph

This is useful for visualizing how branches diverge and when they were merged

git log --graph --oneline --all

Display commits with a visual branch graph
This view is useful for understanding how different branches split off from each other and when they were merged back in.

git log --graph

Show commits of any user

git log --author="name or email"

Use this command to show commit history filtered by author name or email.
It's useful when you want to see only the commits made by a specific person.

📌Additional Tips

Press q to exit the git log output screen
Use git log -p to view detailed code changes for each commit
Use git log --since="2 weeks ago" to filter commits by a specific time range

🔥 GIT RESTORE

📌 What is git restore?

git restore is a command used to safely and easily revert changes to files or restore them to a previous state.
It was introduced in Git 2.23 as a safer and clearer alternative to certain uses of git checkout.

💾 1. Discard changes to files (that haven't been added yet)
Use this when you’ve modified files but haven’t staged them, and want to undo the changes:

git restore <filename>

Revert the file back to its state in the latest commit.

All changes in the file will be lost! (It’s not in staging and hasn’t been committed yet

Example
1.1 If you accidentally delete test.txt
1.2 Then run git status

1.3 You’ll see that Git has detected the file test.txt as deleted.
1.4 When we run the command

git restore test.txt

1.5 We will restore the file to its state before it was deleted.

1.6 The system will restore the file to the state before it was deleted.

💾 2. Unstage files (that have already been added)
Use this when you’ve added files to the staging area by mistake and want to remove them from staging without losing your changes.

git restore --staged <file>

Removes the file from the staging area (similar to git reset filename.txt)
but does not delete the actual changes made to the file.

Example:

git restore --staged main.c

🎉 Now that you understand these basic commands—whether it's starting a project with git init, adding files to the staging area with git add, recording changes with git commit, or checking status and history with git status and git log—you've laid a solid foundation for working with Git at the local repository level.

In the next chapter (Part 3), we'll build on this by exploring collaboration with others through remote repositories using commands like git push, git pull, and git clone, so you can manage projects smoothly with your team.

Git Full Speed Ahead Part 1: Installing Git on Windows and Getting Started in No Time

Pawinphat Charoenrat — Sat, 19 Jul 2025 06:59:36 +0000

In today’s programming world, version control is essential — and Git has become a must-have tool for every developer.
This article will walk you through a quick Git installation on Windows, so you can get up and running in no time.

1.🔧 The Starting Point: Why Do We Need Version Control?
When multiple developers work on the same codebase, problems often arise:

Who changed what?
Which version is the most up-to-date?
Accidentally deleted someone’s work — and can’t undo it!

👉 That’s why Version Control Systems (VCS) were created.

2. 🧱 The Early Days: Centralized Version Control Systems (Centralized VCS)

The core idea: there’s a central server that stores all the code and its history.
Developers must connect to this server to pull or push code.
Think of it like a shared filing cabinet in an office — everyone has to take turns using it.
Examples: SCCS, RCS, CVS, Subversion (SVN)

The downsides:

If the server goes down, everyone is blocked.
Offline work is nearly impossible.
Merging code is slow and complicated.
Branching is inconvenient and limited.

3. 🌐 The Next Era: Distributed Version Control Systems (DVCS)

A new concept: everyone has a full copy of the code and its history on their local machine.
This enables offline work, smoother merges, and faster branching.

4. 🚁 The Birth of Git

The Linux development team originally used BitKeeper (a VCS), but a licensing issue arose in 2005.
As a result, Linus Torvalds created Git from scratch — in just a few weeks.

😕 Many People Confuse Git with GitHub

Git and GitHub are not the same thing. Here's a quick breakdown:

✅ Git is a version control tool that runs locally on your machine.

✅ GitHub is an online platform where you can store, share, and collaborate on Git repositories with others.

💡 So, How Is GitHub Different from Git?

Git	GitHub
A program that runs locally	An online platform/website
Manages code versioning	Used for storing, sharing, and collaboration
Works offline	Requires internet to sync
Can be used with services like GitLab, Bitbucket	A service provided by GitHub only

🎳Let’s Create a GitHub Account and Repository !

1. Go to GitHub
2. Create a repository or click on your profile

3. After clicking "Your repositories", click "New" to create a new repository.

4. Enter a name for your repository.

5. Add a description and set the repository's visibility (public or private).

5.1 Add a Description

Description: This is a short explanation of what your project is about. It’s optional, but I highly recommend adding one — even a brief line helps you remember the project's purpose later.

6. Repository Visibility:

Public – Choose this if you want to share your code with others.
Private – Choose this if it’s for personal use or not ready for public view.

7. Optional Files: You can also choose to initialize your repository with helpful files like:

A README.md to describe your project in more detail.
A .gitignore to specify which files Git should ignore.
A license file, if you're open-sourcing your project.

8. Once the repository is created, you’ll see a screen like this:

📚Deleting a Repository

To delete a repository:

1. Go to your Profile > Your repositories

2. Select the repository you want to delete

3. Click on Settings in the selected repository

4. Scroll down to the Danger Zone section and click Delete this repository

5. GitHub will ask you to confirm by typing the repository name into the box.
Then, click Delete this repository to permanently remove it.

🤾Let’s Start Using Git

Installing Git
1. Download the installer from https://git-scm.com and click Download

2. Choose the operating system that matches your machine (I’m using Windows).

3. Install Git (if there are no special options you want to change, just keep clicking Next — the default settings are good to go).

4. Once the installation is complete, you’ll see a window like this:

5. After installation, open Git Bash. Here’s how:

6. Type Git Bash in the search box.

git bash .

7. To check if Git is installed and see which version you're using, run the following command:

git --version

8. To check your current Git configuration, use the following command:

git config --list

9. Setting Your Email in Git

To set your email in Git, run the following command:

git config --global user.email "you@example.com"

10. Setting Your Name in Git

To set your name in Git, use the following command:

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

11. When you run the git config --list command, you should see your configured email and username displayed in the list.

Now you’ve successfully installed Git and configured it — you're all set!
🚀 In Part 2, we’ll dive into real Git commands like clone, commit, push, and pull to get you ready for real-world projects!

How to Supercharge Your ESP32 Projects with Gemini CLI (Step-by-Step)

Pawinphat Charoenrat — Wed, 09 Jul 2025 09:53:25 +0000

👋Quick Introduction
Supercharge your ESP32 development with the power of AI!
In this guide, you’ll learn how to use Google Gemini CLI as your coding companion for ESP-IDF projects inside Visual Studio Code. Whether you're writing C code, debugging tricky logic, or generating helpful docs—Gemini CLI brings real-time AI assistance right into your workflow.

🔧 What You’ll Need
Here’s a quick checklist to get started:

An ESP32 board (e.g., Ai-Thinker or similar)
A USB cable for connection
A Windows PC
Visual Studio Code with the ESP-IDF extension
Basic familiarity with ESP-IDF
An active internet connection

🧩 Step 1 – Installing Node.js
Before using Gemini CLI, you’ll need to have Node.js installed. We recommend version 18 or higher.

To check if Node.js is already installed on your system,
open PowerShell and run:

node -v

example check nodejs

If you see a version number, you're good to go. If not, head over to nodejs.org and install the latest LTS version.

🧩 Step 2 – Installing Gemini CLI
Once Node.js is set up, it’s time to install the Gemini CLI.

Open PowerShell and run the following command:

npm install -g @google/gemini-cli

example install gemini cli

Once the installation finishes, the Gemini CLI is ready to go!

🧩 Step 3 – Running Gemini for the First Time
To launch Gemini CLI for the first time, simply run:

gemini

example open gemini

On the first launch, the system will prompt you to choose a theme for the CLI interface.

🎨 Don’t worry—you can change the theme later if you want. This is just for customizing the look and feel of your terminal experience.

After choosing your preferred theme, you’ll be prompted to sign in.

By default, Gemini CLI uses Google Sign-In, so just follow the instructions to log in with your Google account.

🔐 This step is required so Gemini CLI can access the Gemini API on your behalf.

Once you're signed in, you're ready to start chatting with Gemini right from your terminal!

✅ And that’s it—Gemini CLI is now ready to use!

You can start using AI to help with your ESP32 development right inside your terminal. Ask it to write code, explain functions, fix bugs, or even translate text—it’s like having a coding assistant built into your workflow.

🧩Step 4 – Running a Build: Command vs AI Prompt
Traditionally, you would build your ESP32 project using the terminal:

idf.py build

But with Gemini CLI, you can simply type a natural language prompt like:

🧠 “Build my ESP-IDF project”

Gemini understands what you mean and helps generate or run the correct command—saving you time and minimizing context switching between docs and terminals.

You can go beyond just building. Try asking Gemini to:

“Flash this project to my ESP32 board.”
“Clean and rebuild my ESP-IDF project.”
“Why am I getting a CMake error when I build?”
“Suggest compiler flags for faster build.”

It’s like having a smart assistant who knows both ESP-IDF and your codebase—right there in your terminal.

Example ESP-IDF Build

🧩 Step 5 – Using Gemini CLI Inside the ESP-IDF Terminal in VS Code
Now let’s try using Gemini CLI directly inside the ESP-IDF environment within Visual Studio Code.

To do this, open the dedicated ESP-IDF terminal by pressing:

Ctrl + Shift + P → then select
ESP-IDF: Open ESP-IDF Terminal

This gives you a pre-configured terminal with all the necessary environment variables set up—perfect for running ESP-IDF commands or interacting with Gemini CLI.

Once the ESP-IDF terminal is open, just type:

gemini

This will launch the Gemini CLI right inside your dev environment—ready to take your prompts and help you out in real time.

I gave Gemini a simple prompt to try building my project.
Here’s an example of what I typed:

ฺฺBuild ESP-IDF Project

Gemini will then ask for confirmation to start the build.
Just press Enter to continue.

✅ If everything goes smoothly, Gemini will confirm that the build finished successfully—no issues at all.

🚀I Tried Using Gemini CLI to Catch Bugs in My ESP32 Code—Here’s What Happened

I deliberately wrote some incorrect code to test Gemini.

For example, I changed this line:

ESP_LOGI(TAG_Fade, "Initial state: LED is OFF.");

to:

Ex(TAG_Fade, "Initial state: LED is OFF.");

Next, I asked Gemini to build the project for me.

Gemini notified me that the build failed and showed the error.
It then asked if I wanted it to fix the issue.

I just pressed Enter to let Gemini handle the fix.

Gemini showed me the lines it fixed and asked if I wanted to build the project again.

When I built the project again after Gemini’s fixes, everything went through smoothly.

☢️ A quick heads-up:
When Gemini asks if you want to fix an error, choose “yes, allow once”—especially if you’re not sure how many errors your project has.
Try to avoid selecting “yes, allow always”, because Gemini will then automatically fix issues without asking again. Sometimes, it might apply incorrect fixes since you didn’t have a chance to review them first. This can lead to unexpected problems or even cause your project to fail.