DEV Community: Toolloom

Saving Yourself with Git Reflog

Toolloom — Fri, 29 May 2026 05:00:12 +0000

We've all been there: you run a destructive command like git reset --hard or accidentally delete a branch, and panic sets in. Before you accept defeat, remember that Git rarely actually deletes anything immediately. It keeps a secret history of every single action you take locally in a tool called the reflog.

Just type git reflog in your terminal to see a list of your recent movements, even the ones you thought you lost. Once you find the commit hash from right before your mistake, you can run git reset --hard to bring your code back from the dead. It's the ultimate undo button for Git.

Stop Writing print('var =', var) in Python

Toolloom — Thu, 28 May 2026 21:00:13 +0000

We've all been there: quickly sprinkling print statements throughout our code to see what a variable holds during runtime. But writing 'print(f"user_id: {user_id}")' over and over gets tedious. Next time, try the f-string shortcut by adding an equals sign after the variable name: 'print(f"{user_id=}")'.

This will automatically output both the variable name and its value (for example, 'user_id=42'), saving you keystrokes and making your quick-and-dirty debugging sessions much faster. It even works with expressions, like 'print(f"{len(users)=}")'!

Master the Art of Selective Commits with 'git add -p'

Toolloom — Thu, 28 May 2026 21:00:13 +0000

Ever finished a long coding session only to realize you've written three different features, fixed a bug, and left a bunch of debug console.log statements in a single file? Instead of committing everything in one massive, chaotic dump, use 'git add -p' (or '--patch'). This command lets you review your changes hunk by hunk, deciding exactly what goes into the staging area and what stays out.

It's like having a final code review with yourself before making things official. You can stage the actual feature, discard the debug statements, and keep your git history incredibly clean and readable for your team.

Supercharge Your Editing with VS Code's Multi-Cursor Magic

Toolloom — Thu, 28 May 2026 21:00:13 +0000

If you're still manually renaming variables or editing identical lines of code one by one, it's time to embrace multi-cursor editing. In VS Code, simply highlight a word and hit Ctrl+D (or Cmd+D on Mac) to automatically select the next occurrence of that word. Each press adds a new cursor, allowing you to edit all of them simultaneously.

If you want to select all occurrences at once, use Ctrl+F2 (or Cmd+F2). It's a massive timesaver that keeps you in the flow and prevents the tedious copy-paste cycle.

Lost your commits? Git reflog to the rescue!

Toolloom — Thu, 28 May 2026 05:00:09 +0000

We've all been there: you perform a force push, a messy rebase, or accidentally delete a local branch, and suddenly your hard work seems gone forever. Before you panic, run git reflog in your terminal. Git keeps a silent, chronological diary of almost every action you take locally, even if those commits are no longer attached to any active branch.

Once you find the commit hash of your lost work in the reflog list, you can easily resurrect it by running git checkout or creating a new branch from that point. It's the ultimate safety net that will save your skin more than once.

Master Selective Commits with git add -p

Toolloom — Wed, 27 May 2026 21:00:09 +0000

Ever finished a long coding session only to realize your working directory is a mess of different logical changes? Instead of staging everything at once with git add ., try using git add -p (or --patch). This command runs an interactive session that steps through your changes hunk by hunk, letting you decide exactly what goes into the next commit.

You can stage a specific change, skip it, or even split a large hunk into smaller pieces. It's an absolute game-changer for keeping your commit history clean, readable, and easy to review during pull requests.

Quick Debugging in Python with f-string Self-Documenting Expressions

Toolloom — Wed, 27 May 2026 21:00:09 +0000

If you still find yourself writing print(f"user_id: {user_id}") to debug your Python code, there's a much cleaner way. Since Python 3.8, you can add an equals sign = inside the curly braces of your f-string to print both the expression and its evaluated value.

Simply write print(f"{user_id=}") and Python will automatically output user_id='12345'. It works for expressions and function calls too, saving you a ton of keystrokes during quick debugging sessions.

Level Up Your JS with Logical Assignment Operators

Toolloom — Wed, 27 May 2026 05:00:12 +0000

If you are still writing if (!settings.theme) settings.theme = 'dark'; or even settings.theme = settings.theme || 'dark';, it is time to simplify. Modern JavaScript gives us logical assignment operators that combine logical operations with assignment in a clean, readable way.

By using settings.theme ||= 'dark', you only assign 'dark' if settings.theme is falsy. Even better, use the nullish coalescing assignment operator (??=) to only assign a value if the variable is strictly null or undefined. This prevents pesky bugs where valid falsy values, like 0 or an empty string, accidentally get overwritten.

Master the Multi-Cursor Skip in VS Code

Toolloom — Wed, 27 May 2026 05:00:12 +0000

Most devs know that pressing Ctrl+D (or Cmd+D on macOS) selects the next occurrence of the highlighted word. It’s a game-changer for quick renaming. But what happens when you accidentally select a variable you didn't want to change?

Instead of hitting escape and starting all over, you can use Ctrl+K followed by Ctrl+D (or Cmd+K then Cmd+D on Mac). This nifty combo skips the currently highlighted occurrence and jumps straight to the next one, keeping your other selections intact. It's a massive time-saver when refactoring.

Clean Up Your Commit History Effortlessly with Git Fixups

Toolloom — Wed, 27 May 2026 05:00:12 +0000

We've all been there: you submit a pull request, notice a tiny typo, and end up making a commit named "fix typo" or "temp." Instead of cluttering your git history, try using git commit --fixup [commit-hash] when committing the fix. This marks your new change as a fixup of that specific older commit.

When you're ready to clean things up before merging, run git rebase -i --autosquash origin/main. Git will automatically organize your interactive rebase todo list, placing the fixup commits directly beneath their parent commits and marking them to be melted in. It keeps your commit history pristine without the manual drag-and-drop headache.

Master the Art of Selective Commits with Git Patch

Toolloom — Tue, 26 May 2026 21:00:12 +0000

Ever finished a long coding session only to realize you've written three different features and a hotfix all in the same files? Instead of committing one giant, chaotic mess, use 'git add -p' (or '--patch'). This command takes you through your changes chunk by chunk, letting you decide whether to stage, skip, or even split each specific modification.

It's a fantastic way to keep your commit history clean, readable, and easy to roll back if something goes wrong. Plus, reviewing your code line-by-line before staging acts as a great final self-review to catch silly mistakes before they ever reach your repository.

Quick and Dirty Python Debugging with the f-string '=' Shortcut

Toolloom — Tue, 26 May 2026 21:00:12 +0000

We've all been there: sprinkling 'print()' statements all over our Python code to figure out why a variable isn't what we expect. Instead of typing 'print(f"user_id: {user_id}")', save yourself some keystrokes by using the '=' shortcut inside your f-string. Simply write 'print(f"{user_id=}")'.

Python will automatically expand this to print both the variable name and its evaluated value, outputting 'user_id=42'. It even works for expressions, like 'print(f"{len(users)=}")'. It's a small, built-in trick that makes quick print-debugging much faster and cleaner.