Tools & Tips on entangledDEV

Git How-Tos I Reach For Daily Work

Mon, 27 Oct 2025 17:42:48 +0000

This is my running log of Git moves I reach for when I do work. Each mini-how-to includes the exact commands plus a quick note on what to watch for.

Squash Multiple Commits Into One

Use interactive rebase to collapse the last n commits into a single, tidy changeset.

Optional safety: create a backup branch before rebasing:

git branch backup/feature-branch-before-squash

git rebase -i HEAD~3

Replace 3 with however many commits you want to include, counting the current HEAD as part of that total. HEAD refers to the current commit, HEAD~1 to its parent, HEAD~2 to the one before that, and so on. When you run git rebase -i HEAD~3, Git lists the last three commits including HEAD. Run git log --oneline to count backward until you reach the oldest commit you intend to squash.

Tip: Use HEAD~3^ if you need to include the fourth commit in the interactive list.

For example, if your history looks like this (newest first):

a1b2c3 (HEAD)
d4e5f6
g7h8i9
j0k1l2

The command git rebase -i HEAD~3 opens the editor with:

pick j0k1l2
pick g7h8i9
pick d4e5f6

In the editor:

Leave the first commit as pick
Change the rest to squash (or s)
Save, then compose the final commit message

If conflicts appear, resolve them and resume with git rebase --continue.

To abort the squash at any point, run:

git rebase --abort

Force Push After Squashing

Once history changes, update the remote branch.

git push --force-with-lease origin feature/my-branch

--force-with-lease protects teammates by refusing to overwrite work you haven’t fetched.

Create a Local Repo and Wire Up a Remote

mkdir my-project && cd my-project
git init
# add files, then commit
git add .
git commit -m "Initial commit"
git remote add origin git@github.com:username/my-project.git
git push -u origin main

If the remote is empty, main (or master) becomes the default branch once you push with -u. Double-check the URL format (git@ for SSH, https:// for HTTPS) before adding the remote.

Track a Remote Branch Locally

When you create a local branch that should follow an existing remote branch, set the upstream explicitly.

git switch -c feature/api-integration origin/feature/api-integration
# or, if branch already exists locally
git branch --set-upstream-to=origin/feature/api-integration

Now git pull and git push know which remote branch to use. If Git complains that the remote ref is missing, fetch it first (git fetch origin feature/api-integration) and rerun the command.

Create a Branch and Push It Upstream

Shortcut to create a branch, commit, and publish it with upstream tracking in one go.

git switch -c feature/search-bar
git commit -am "Add search bar styles"
git push -u origin feature/search-bar

-u (or --set-upstream) wires the remote for future pushes. Remember that git commit -am only stages files Git already tracks—run git add first if you created new files.

Sync With the Latest From Main Without Merge Commits

Rebase your current branch onto main to replay your commits on top of the latest state.

Optional safety: create a backup before rebasing:

git branch backup/feature-search-bar-before-rebase

Make sure you have no pending edits: git status -sb should report a clean tree.
Update main so you are rebasing onto the real latest code.
```
git switch main
git pull --ff-only origin main
```
Return to your feature branch (replace with your branch name).
```
git switch feature/search-bar
```
Replay your commits on top of the freshly updated main.
```
git rebase main
```

⚠️ Rebase pointer:
In merges: ours = current branch, theirs = incoming.
In rebases: ours = target branch, theirs = replayed commit.
Pick the pieces you need, git add each resolved file, and continue with git rebase --continue.
If the rebase turns chaotic, bail out with git rebase --abort.

Once the history looks right, rerun your tests and publish the new linear history:

git push --force-with-lease origin feature/search-bar

If you prefer to preserve merge commits instead, use git merge origin/main.

Rebase Onto the Remote Version of Your Branch

When teammates update the remote feature branch, pull those commits in and resolve conflicts locally.

Optional safety: create a backup before rebasing:

git branch backup/feature-payment-before-rebase

Ensure a clean tree first: git status -sb.
Update your knowledge of the remote branch.
```
git fetch origin feature/payment
```
Switch to your local branch that you want to replay.
```
git switch feature/payment
```
Rebase onto the remote tracking branch you fetched.
```
git rebase origin/feature/payment
```

⚠️ Rebase pointer:
In merges: ours = current branch, theirs = incoming.
In rebases: ours = target branch, theirs = replayed commit.
Merge the pieces you want, stage them with git add, and continue (git rebase --continue).
If the rebase turns chaotic, bail out with git rebase --abort.
Alternatively, if your upstream is set, you can pull and rebase in one step:

git pull --rebase

After the rebase, rerun tests and share the rewritten history safely:

git push --force-with-lease origin feature/payment

Cherry-Pick a Fix Onto Another Branch

Grab a single commit and apply it elsewhere.

git switch release/1.2
git cherry-pick <commit-sha>

If conflicts arise, fix them, git add the files, and run git cherry-pick --continue.

For multiple commits, cherry-pick a range (the upper bound is exclusive):

git cherry-pick A..B

Tip: Use A^..B if you want to include commit A itself.

Quick Patch From a File Diff

Generate a patch for one file and drop it into another branch or repo.

git diff main..feature/payment checkout.swift > checkout.patch
git switch hotfix/payment-crash
git apply checkout.patch

Review the applied changes before committing.

git apply only affects the working tree; follow up with git add and git commit once you confirm the patch looks right.

Tip: Run git am checkout.patch instead if you want to preserve the original author and commit message from the patch.

Merge Main Into Your Branch (Keep the Merge Commit)

If your team relies on merge commits for context, integrate the latest main without rewriting history.

git fetch origin
git merge --no-ff origin/main

Resolve conflicts, run the test suite, and let Git create the merge commit message. --no-ff retains the merge node even when a fast-forward is possible, preserving the branch narrative.

See What Changed Between Two Branches

Compare your feature branch to main, highlighting only the files or commits that differ.

git log --oneline main..feature/billing
git diff --stat main...feature/billing

Two dots (..) show unique commits; three dots (...) reveal files that diverged from the common ancestor.

Undo the Last Commit (Keep Changes)

Keep your working tree but remove the most recent commit.

git reset --soft HEAD~1

HEAD is the current commit, so HEAD~1 targets the one before it. The changes remain staged. To unstage but keep edits, use git reset --mixed HEAD~1.

Recover Work You Thought Was Gone

If a commit vanished after a reset or rebase, scan the reflog.

git reflog

You can use git show <reflog-sha> to inspect the commit before checking it out.

git switch --detach <reflog-sha>

Create a new branch from that SHA to rescue the work: git switch -c rescue/forgotten <sha>.

Stash Selective Files

Avoid stashing the whole tree by selecting specific paths.

git stash push -- src/HomeView.swift
git stash list
git stash pop

Combine with --keep-index to stash only unstaged changes. Stashes are stored in order; use git stash list to view entries and git stash pop stash@{1} to apply a specific one.

Clean Untracked Files Safely

Preview deletions before scrubbing untracked files and directories.

git clean -nd
git clean -fd

-n performs a dry run; -f is required to delete, and -d includes directories. Double-check the dry-run output carefully—git clean is irreversible once it runs with -f.

Revert a Commit That Already Hit Main

Create a new commit that undoes a previous one (keeps history intact).

git revert <commit-sha>

Grab the commit SHA from git log --oneline. If the revert itself fails because of conflicts, resolve them, git add the files, and run git revert --continue.

Tip: Need to revert several commits in one go? Use git revert -n <sha1> <sha2> ... to stage the reversions and commit once at the end.

Rename a Branch Locally and Remotely

git branch -m old-name new-name
git push origin --delete old-name
git push -u origin new-name

If the branch is protected, you may need admin permissions (or to lift protection temporarily) before deleting it remotely. Afterwards, clean up stale references locally:

git fetch --prune

Anyone else using the old branch should do the same and check out the new name.

I add to this page whenever I find myself repeating a Git flow. If you’re reading along and need another scenario covered, let me know and I’ll expand the list.

Inspecting your network traffic in Apple Platforms

Fri, 03 Oct 2025 17:21:27 +0000

Debugging HTTPS calls on iOS and iPadOS usually means reaching for a TLS proxy that can show you encrypted payloads. Charles Proxy remains a reliable option because it integrates with Apple devices, supports on-the-fly rewriting, and lets you archive sessions for later analysis. This guide walks through the minimal setup to get your device routing traffic through Charles without breaking App Transport Security (ATS).

Prerequisites

Charles Proxy 4.6 or newer installed on your Mac.
The iOS or iPadOS device connected to the same Wi‑Fi network as the Mac running Charles.
Developer access to the app you are testing so you can safely tweak networking settings if needed.

Configure the Wi‑Fi proxy on the device

Open Settings → Wi‑Fi on your device and tap the ℹ︎ icon next to the active network.
Scroll to Configure Proxy and choose Manual.
Enter your Mac’s local IP address in Server. You can find it in System Settings → Network or by running ipconfig getifaddr en0 on macOS.
Set Port to 8888 (Charles’ default) and leave Authentication off unless you enabled it in Charles.
Tap Save. Traffic now routes through your Mac for that Wi‑Fi network only.

Keep Charles open; if the proxy stops listening, iOS calls will fail immediately with NSURLErrorCannotConnectToHost.

Install and trust the Charles SSL certificate

Charles needs to present its own certificate so it can decrypt HTTPS. Apple treats any custom certificate as untrusted until you explicitly approve it.

On the device, open Safari and navigate to https://chls.pro/ssl.
Safari downloads a configuration profile and shows an Profile Downloaded banner. Tap it or go to Settings → General → VPN & Device Management.
Under Downloaded Profile, select Charles Proxy CA and tap Install. Confirm with your passcode and approve the warning prompts.
Navigate to Settings → General → About → Certificate Trust Settings.
Under Enable Full Trust For Root Certificates, toggle on Charles Proxy CA and confirm. Without this step, every HTTPS connection will fail due to trust errors.

Once trusted, Charles can decrypt traffic for domains that permit re-signing. ATS exceptions are unnecessary unless the app pins certificates or forbids proxies.

Verify the capture

In Charles, hit the Start Recording button (red circle). Leave Proxy → macOS Proxy off when you only care about physical devices; toggle it on if you also want macOS apps or simulators to route through Charles.
Launch your app and repeat the network flow you want to inspect.
Requests should stream into Charles’ session list. Double-click an entry to view request headers, response payloads, and TLS information.
Use Tools → SSL Proxying Settings to add specific hosts if Charles reports SSL handshake failed. Add domains with wildcards (for example, api.example.com or *.example.com).

If your traceroute stays empty, confirm the device still uses the same Wi‑Fi network and that no VPN profiles override your proxy settings.

Troubleshooting tips

Certificate pinning: Apps that implement SSL pinning will reject Charles’ certificate. Disable pinning in a debug build or use a build flavor without pinning to capture traffic.
HTTP/3 traffic: Charles downgrades HTTP/3 to HTTP/2. If your API strictly requires QUIC, test with Apple’s PacketLogger or consider Proxyman/mitmproxy with HTTP/3 support.
Background sessions: Background URLSession traffic may not route through the proxy when the app is suspended. Keep the screen awake or use Instruments’ HTTP template for background captures.
Different networks: Switching Wi‑Fi networks clears the proxy configuration. Re-apply the manual proxy after every network change.

Clean up when finished

Return to Settings → Wi‑Fi → (ℹ︎) and set Configure Proxy back to Off (or Automatic).
In Settings → General → About → Certificate Trust Settings, disable the Charles Proxy CA toggle.
Optionally remove the profile from VPN & Device Management to keep the device’s trust store clean.

Resetting both the proxy and certificate ensures future HTTPS requests use your production trust chain and keeps users from accidentally routing through a dormant proxy.

With these steps in place you can capture, inspect, and replay network flows directly from real devices, which is invaluable when simulator behavior diverges from field reports.

VSCode Dev Container Configurations

Tue, 21 May 2024 00:46:23 +0000

VSCode + Dev Containers are a great way to create custom environments without modifying our actual system.

They provide a consistent development environment, ensure dependencies are managed correctly, and make it easy to share setups with your team.

Here are some configurations you can use to create them.

Vapor

{
    "name": "Swift",
    "image": "swift:latest",
    "features": {
        "ghcr.io/devcontainers/features/common-utils:2": {
            "installZsh": "false",
            "username": "vscode",
            "userUid": "1000",
            "userGid": "1000",
            "upgradePackages": "false"
        },
        "ghcr.io/devcontainers/features/git:1": {
            "version": "os-provided",
            "ppa": "false"
        }
    },
    "runArgs": [
        "--cap-add=SYS_PTRACE",
        "--security-opt",
        "seccomp=unconfined"
    ],
    "customizations": {
        "vscode": {
            "settings": {
                "lldb.library": "/usr/lib/liblldb.so"
            },
            "extensions": [
                "sswg.swift-lang",
                "streetsidesoftware.code-spell-checker"
            ]
        }
    },
    "remoteUser": "root",
    "postCreateCommand": "apt-get update && apt-get install -y libssl-dev libsqlite3-dev zlib1g-dev make && rm -rf toolbox && git clone https://github.com/vapor/toolbox.git && cd toolbox && make install && cd .. && rm -rf toolbox"
}

Scala

{
	"name": "Scala",
	"image": "mcr.microsoft.com/devcontainers/java:1-21-bullseye",

	"features": {
		"ghcr.io/devcontainers/features/java:1": {
			"version": "none",
			"installMaven": "false",
			"installGradle": "false"
		}
	},
	"postCreateCommand": "curl -fL https://github.com/VirtusLab/coursier-m1/releases/latest/download/cs-aarch64-pc-linux.gz | gzip -d > cs && chmod +x cs && yes | ./cs setup && echo 'before start run source ~/.profile'",

	"customizations": {
		"vscode": {
			"extensions": [
				"scala-lang.scala",
				"streetsidesoftware.code-spell-checker"
			]
		}
	}
}

Fully Reload Websites in Safari

Fri, 22 Dec 2023 01:40:53 +0000

One common challenge encountered during frontend development is the persistence of cached data in web browsers.

While browser caches efficiently save time by storing assets and eliminating the need to download them on every website visit, they can pose problems during development when changes are made to the code.

How to Force a Full Reload in Safari with All Assets

In Safari, resolving this issue is a straightforward process.

Ensure that Developer Tools are enabled by pressing CMD + ,. Next, navigate to the Advanced tab, and at the bottom of the window, select Show features for web developers. Now you can close this settings window.

To perform a full reload, simply press CMD + OPT + R (Safari 11+). This action reloads the current page, bypassing any cached data present in Safari.

Conclusion

By incorporating this simple tip into our workflow, we can enhance efficiency in frontend development, particularly when dealing with assets.

It can be frustrating not to see updated images, leading us to question our code. However, in many cases, it’s just the cache doing its job.

I trust this brief post proves helpful in resolving such issues.

Until next time!

Deleting Duplicates Subdirectories and Content

Fri, 22 Dec 2023 01:13:31 +0000

The other day, I encountered an issue involving three directories, and two of them contained a subdirectory with the same name (target).

My goal is to delete the target subdirectories in all places with a single command, and here’s the solution I found.

Using the terminal to delete multiple directories.

There is an useful command called find, this command is used to traverse nested directories and evaluate an expression for each element.

We can use find to delete files or directories, here is the command:

find . -type d -name "target" -exec rm -rf {} +

Understanding the command

This command is easy to grasp, first we have ., this is telling find to start traversing in the current directory.

Next we have -type, this argument allows to select a a specific valid type.

The valid types are listed below:

b: block special
c: character special
d: directory
f: regular file
l: symbolic link
p: FIFO
s: socket

Since we need to find an specific directory we use d.

Next it’s -name, we need to give the string that contains the name we are searching for. In our case we are looking for the directories named "target".

The last part of the command, -exec, is telling what to do once we find a valid element. In this case we want to delete all the found occurrences, so we’re passing rm -rf.

The {} is just telling that we need to use the current element’s name, and + is used to terminate the -exec part.

Conclusion

By using this simple command we can find and delete subdirectories in an easy and convenient way, which I find to be faster than using the GUI.

I hope this simple tutorial can help you to solve these kind of problems.

Comparing Files in Vscode

Tue, 07 Nov 2023 16:58:58 -0600

Today, I’d like to share a simple trick for comparing the states of files using both the terminal and VSCode.

Comparing files

Typically, when we need to check for differences between two files, we can use git diff if the files are within a Git repository or simply diff if the files are local.

However, these commands lack a user-friendly interface for comparing files, which is where VSCode’s file comparison feature comes in handy.

Steps 👍

First, we need to obtain the file paths of the files we want to compare.
Open your terminal and run the following command: code --diff /path/fileA /path/fileB, then press Enter.

VSCode will open, displaying the differences between both files in a clear and user-friendly manner.

Additionally, any changes you make to the files during this comparison can be conveniently saved back to the original files.

Conclusion

For swift and efficient file comparison, VSCode provides a valuable graphical user interface (GUI). This nifty trick can save time and help prevent mistakes, as you can instantly see how your changes impact the differences between the files.

Working With Git Submodules

Wed, 25 Oct 2023 00:03:41 -0600

The other day, I was working on a project that had a Git submodule. Initially, I found it a bit tricky to make it work, so I decided to create a short tutorial on this.

What is a Git submodule

Essentially, a Git submodule is a way to include one Git repository inside another Git repository. This creates a nested structure.

So, in simple words, a Git submodule is like a mini Git repository that you can include in your main Git repository to use and update external code or resources without actually putting all of their files directly in your project.

The crucial point to note is that, by default, the code of the submodule is not added to your Git repository when performing the initial git clone.

How to check the ulr of the git submodule

To check the linked URLs of submodules we can use this command.

git config --file .gitmodules --get-regexp 'submodule\..*\.url'

How to clone a submodule

There could be three situations:

You want to clone the git project with all its submodules for the first time.
You’ve cloned the git project but didn’t fetch the submodules.
You want to update the submodules in your project.

Cloning a project with all submodules for the first time

If you want to clone a project for the first time with all its submodules, you can run the following command.

With Git version 2.13 or newer.

git clone --recurse-submodules -j8 https://github.com/your/repo.git

-j8 is an optional performance optimization that became available in version 2.8, and fetches up to 8 submodules at a time in parallel

Before Git 2.12.

git clone --recursive https://github.com/your/repo.git

Cloning the submodules only

If you’ve downloaded the project but forgot to fetch the submodules, you can use this command.

git submodule update --init --recursive

If you’ve cloned only the main Git repository, you’ll be missing the submodule files, potentially causing your project to fail.

Updating the submodules

If you want to update the code of the submodules, you need to run this command.

git submodule update --recursive --remote

This will only update the branch registered in the .gitmodule, and by default, you will end up with a detached HEAD, unless –rebase or –merge is specified or the key submodule.$name.update is set to rebase, merge or none.

Adding a submodule to a git repository

To add another remote Git repository as a submodule to your current Git repository, you can use this command.

git submodule add https://github.com/your/repo.git path/to_save/in_repo

The provided code allows you to specify the remote URL for the repository you want to use as a submodule, as well as the path within your project where you want to save the cloned code.

Delete a Git submodule from your project

This process is common but not that straightforward, here are the steps you need to do.

The files mentioned in the following steps are located in the root directory of your project, which is the default location for the Git files.

Delete the relevant line from the .gitmodules file.
Delete the relevant section from .git/config.
Run git rm --cached path_to_submodule (no trailing slash).
Commit and delete the now untracked submodule files.

A trailing slash is the slash that can be added to the end of the path. submodules/my_submodule/ has a trailing slash while submodules/my_submodule doesn’t have one.

Conclusion

Git submodules are a powerful feature for managing dependencies in your projects. They allow you to include external Git repositories within your main repository without cluttering it with their files. This can be especially handy when you’re working on projects that rely on external code or resources.

We’ve covered some essential aspects of working with Git submodules in this tutorial. You’ve learned what a Git submodule is and how to check the URLs of linked submodules. You also know how to clone a project with all its submodules, how to retrieve submodules if you’ve forgotten them, and how to keep them updated. Furthermore, we discussed adding and deleting a submodule from your Git repository.

With this knowledge, you’ll be better equipped to manage complex projects with Git submodules and streamline your workflow. So, don’t shy away from using them in your projects when they can help you manage external code more efficiently.

Happy coding 🚀!