DEV Community: Chris

Rubber Duck Debugging: Why You Should Keep a Duck on Your Desk

Chris — Wed, 30 Apr 2025 18:15:18 +0000

TL;DR

Rubber duck debugging—a.k.a. rubber ducking—means explaining code aloud to a $2 bath toy. Speaking forces your brain to linearize the problem, surface hidden assumptions, and fix bugs faster than most IDE extensions. Try it once; you'll keep the duck.

Where Rubber Duck Debugging Came From

The practice hit developer lore via The Pragmatic Programmer (1999): place a rubber duck next to your keyboard and narrate every line of code until the flaw reveals itself. It spread because it's cheap, tool-agnostic, and embarrassingly effective.

Why Programmers Have Rubber Ducks — and Why You Should Too

Reason	What Happens in Your Brain
Externalizes working memory	Speaking creates a linear narrative, off-loading details that clog short-term memory.
Triggers the "self-explain" effect	Verbalizing assumptions lights up the same error-detection circuits as a peer code review.
Zero-friction pair programming	The duck never judges, never interrupts, and is always awake at 2 a.m.

For a deeper dive into why clear communication outperforms clever hacks, catch Trisha Gee on Gun.io Frontier → Episode 88: "Soft Skills, Communication, and Programming as a Thinking Activity."

5-Step Rubber Duck Debug Routine (Copy-Paste Checklist)

Summarize the bug in one sentence.
State "expected vs. actual" output.
Walk the input → output path aloud, line by line.
Call out every assumption (e.g., "user_id is always non-null").
Log discoveries immediately in your issue tracker before editing code.

Skip a step and the duck's magic weakens.

Advanced Rubber-Ducking Variations

Technique	Best For	Payoff
Pair-Duck (two devs + duck)	Race-condition sleuthing	Real-time idea bounce-back
Remote-Duck (camera-on stand-up)	Distributed teams	Keeps async work honest
AI-Duck (LLM chat after talking aloud)	3 a.m. solo sessions	Instant doc lookup & code suggestions
Ballmer-Peak Boost	Afternoon slump	See our focus-curve deep dive: Exploring the Ballmer Peak

Short answer: Yes—almost every dev who's tried it keeps coming back, because forcing code into spoken language surfaces hidden assumptions and breaks analysis paralysis.

What real programmers say (sampled from a 100-comment Reddit thread on r/learnprogramming):

Insight	Representative takeaway
Locks in linear thinking	"Saying it out loud arranges the knowledge in a coherent way that includes all details. In your head it's easy to jump over steps."
Exposes silent assumptions	"I only rubber-duck when I'm sure the code should work but doesn't. Talking through control-flow shows where my logic really breaks."
Works with any audience—even cats	Developers reported using spouses, cats, action figures, a testing goat, and Slack channels. The object doesn't matter; the forced explanation does.
Acts as 'last-resort' focus mode	Many treat it as a step after logs, breakpoints, and Google searches fail—it's the mental reset that finally clicks.
Transfers to teaching & tutoring	Ex-tutors noted that explaining concepts out loud is identical to duck-debugging: you discover the gaps only when you teach.
Pairs well with sketches & walks	Several devs combine verbalizing with drawing flows on paper or taking a short walk—anything that offloads working memory.

Anecdotal but consistent results

In the Reddit thread, every commenter who had tried the technique called it "useful," "indispensable," or their "last-resort lifesaver."
No one reported it making things worse—worst-case, you waste 90 seconds describing the bug and move on.

Bottom line: Rubber-ducking isn't a silver bullet, but it's the cheapest, lowest-friction cognitive dump you can do. When logs, breakpoints, and chat-GPT prompts stall, pick up the duck, start talking, and watch missing details leap out.

FAQ (on Rubber Duck Debugging & Rubber Ducking)

Q: Is whispering—or thinking silently—enough?

No. Audible words engage motor-speech pathways that silent reading doesn't.

Q: Can any object replace the duck?

Technically yes, but a dedicated prop cements the ritual. Ducks also add a dash of humor your brain remembers.

Q: Should teams formalize rubber duck debugging?

Absolutely. Add "Have you ducked it?" to your PR checklist and keep a bowl of ducks in the dev pit.

How to Choose Your First Debug Duck

Not all ducks are created equal. The perfect rubber duck should be:

Desk-appropriate size — Big enough to see, small enough not to block your monitor
Expression matters — Go for a slightly confused or curious look (mimics how you feel debugging)
Non-squeaky — Unless you want to annoy your entire open-office floor
Distinctive — A themed duck (astronaut, pirate, etc.) adds personality to your debugging ritual

Pro tip: Some developers name their ducks after legendary computer scientists. There's something satisfying about telling "Grace Hopper" about your pointer arithmetic problems.

Rubber Duck Debugging for Remote Teams

As distributed teams become the norm, rubber ducking has evolved:

Virtual duck backgrounds for video calls signal "I'm in duck-debug mode" to teammates
Slack duck-channels give remote teams a place to post their duck explanations when they need to work through problems asynchronously
Duck-debugging sessions scheduled on team calendars create space for focused debugging without interruption

Beyond Code: Rubber Duck Problem-Solving in Other Domains

The duck's power isn't limited to code. The same verbalization technique works for:

Product specifications — Talking through user stories reveals ambiguities
Technical writing — Explaining documentation aloud highlights missing steps
Architecture planning — Articulating system designs exposes edge cases
Client proposals — Verbalizing deliverables catches scope creep before it happens

Even non-technical team members benefit from a desk duck for thinking through complex problems and decisions.

Getting Your Team Onboard the Duck Train

Introducing rubber duck debugging to skeptical teammates:

Start with a duck bowl in common areas with a simple instructions card
Share a quick win from your own experience ("This duck saved me 3 hours yesterday")
Duck-branded debugging swag (stickers work great) normalizes the practice
Duck retrospectives where team members share what they discovered through ducking

Remember: Like any debugging technique, the duck works best when everyone embraces it without judgment.

Duck Debugging Pro Tips from Gun.io's Senior Engineers

Duck rotation system — Switch ducks monthly to keep the practice fresh
Developer duck collection — Different ducks for different bug types (network ducks, database ducks, etc.)
Pre-commit duck check — Make "explain it to the duck" the last step before pushing code
Duck documentation — Keep a duck-log of bugs solved to spot recurring issues

Senior Gun.io developer Martha Chen puts it best: "My most productive debugging tool isn't my IDE or my terminal—it's my rubber duck named Alan Turing."

Don't Duck Your Hiring Challenges

The last thing you should have to rubber duck is your hiring pipeline. Let us handle that for you. While your developers focus on debugging code with their trusty ducks, our talent team eliminates the need to debug your recruitment process.

Apply to join our developer network →
Hire pre-vetted (and duck-equipped) developers →

How to Store Multi-Line Strings in JSON

Chris — Wed, 23 Apr 2025 21:26:18 +0000

JSON remains the foundation of configuration files, API payloads, and—increasingly—prompt engineering workflows. While its strict syntax ensures data portability, it also presents a challenge: raw line breaks are invalid within JSON strings. This limitation frequently affects developers working with SSH keys, certificates, SQL queries, or extensive Markdown blocks.

With the rise of generative AI technologies, JSON has become even more essential, now powering:

OpenAI function calling & tool invocation – where arguments must conform to strict JSON standards
Prompt-engineering frameworks (LangChain, LlamaIndex) that transmit multi-line prompts and code snippets
JSONL corpora designed for fine-tuning Large Language Models
Vector-store metadata where document chunks require newline-friendly formatting

This guide offers three production-ready storage techniques, best practices for AI prompts, and power tips you can immediately implement in your pipeline.

Why Multi-Line Strings Matter in the AI Era

AI Use-Case	Why Newlines Are Critical
Prompt templates	System or user prompts frequently include code blocks and Markdown formatting
Function calling	You may need to pass complete JSON schemas or SQL queries as arguments
RAG ingestion	Chunked documents stored as JSONL require intact paragraph breaks for quality embeddings
Fine-tuning	Conversation histories in JSONL depend on newline-preserved content for training accuracy

Tip: Storing prompts or documents as an array of lines maintains clean training data and prevents models from hallucinating missing line breaks.

TL;DR

JSON strings cannot contain literal newlines; they must be escaped
The most readable approach: store each line as an array element and use join("\n") at runtime
Alternatives: escape \n within a single long string or base64-encode the entire content
Always generate JSON with a standards-compliant library—JSON.stringify, json.dumps, etc.—rather than manually concatenating strings
Validate with JSONLint or our open-source JSON validation CLI for immediate feedback

Stop Hand-Rolling JSON (Best Practice)

"Use a standards-compliant JSON library instead of constructing raw strings like a monster." — every experienced engineer

Manually constructing JSON through string concatenation is fragile and unsafe. Libraries:

Guarantee validity (proper escaping, no stray commas)
Prevent injection vulnerabilities when untrusted data is interpolated
Enhance maintainability—you modify objects, not delicate text strings

Implementation Examples

JavaScript / Node

const promptTemplate = [
  "You are a helpful assistant.",
  "Answer with JSON only.",
  userMarkdown // multiline Markdown from the front-end
];

const payload = {
  model: "gpt-4o",
  messages: [{ role: "user", content: promptTemplate.join("\n") }]
};

fetch("https://api.openai.com/v1/chat/completions", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${key}`
  },
  body: JSON.stringify(payload)
});

Python

import json, base64
payload = {
    "publicKeyB64": base64.b64encode(b"...pem bytes...").decode()
}
print(json.dumps(payload, indent=2))

1. Array-of-Lines Pattern (Most Readable)

{
  "servers": {
    "servername.com": {
      "publicKey": [
        "-----BEGIN PUBLIC KEY-----",
        "MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0VmDBbzXdgubV/X8JP9B",
        "...snip...",
        "-----END PUBLIC KEY-----"
      ]
    }
  }
}

At runtime:

const publicKey = data.servers["servername.com"].publicKey.join("\n");

Pros: Human-readable, diff-friendly, works with any JSON parser, no additional decode step required.

Cons: Slightly larger payload size; must remember to join().

2. Escaped Newlines (Compact but Less Readable)

{
  "prompt": "You are a helpful assistant.\n\nYour job is to answer questions clearly and concisely."
}

Quality editors highlight \n sequences, but large text blocks become difficult to compare. This format represents how your JSON will ultimately look after serialization by a standard library. Remember that you should never manually insert escape sequences yourself—always use proper serialization libraries like JSON.stringify() or json.dumps() to ensure correct escaping and avoid subtle bugs.

3. Base64 Encoding (Required for Binary Data)

{
  "publicKeyB64": "LS0tLS1CRUdJTiBQVUJMSU...=="
}

import { Buffer } from "node:buffer";
const publicKey = Buffer.from(data.publicKeyB64, "base64").toString("utf8");

Ideal for certificates (PEM/DER), images, or any binary content that doesn't require visual inspection.

Designing Prompt Schemas (Metadata-First DSL)

Rather than delivering a single monolithic prompt string, many engineering teams now structure prompts as organized fields—effectively creating a domain-specific language (DSL) built on JSON:

{
  "system": "You are a helpful assistant.",
  "instructions": "Always respond in a calm, informative tone.",
  "example_input": "What is the capital of France?",
  "example_output": "The capital of France is Paris."
}

Benefits

Clear separation between system message, user instructions, and examples
Easier to tokenize, version-control, and troubleshoot than a massive text block
Compatible with OpenAI function calling and other schema-driven APIs

Store Prompts as Markdown → Compile to JSON

For maximum readability with non-technical stakeholders, maintain prompts in plain Markdown (.md or .prompt) and compile them during your build process:

prompt.md

You are a contract-lawyer AI.

Your task is to:
1. Summarize obligations
2. List liabilities
3. Flag deadlines

build.js

import fs from "fs";
const prompt = fs.readFileSync("prompt.md", "utf8");
const job = { role: "system", content: prompt.replace(/\r?\n/g, "\n") };
fs.writeFileSync("prompt.json", JSON.stringify(job));

Validation & Linting

Before committing your changes, run:

jsonlint config.json

or paste your JSON into JSONLint. Both tools immediately identify stray control characters.

Security Considerations

When working with multi-line strings in JSON, keep these security aspects in mind:

Injection Risks

The Array-of-Lines pattern inherently provides better isolation of potentially malicious strings
Always validate input before parsing to prevent JSON injection attacks
For user-generated content, consider additional sanitization beyond standard JSON escaping

Sensitive Data Handling

Avoid storing credentials directly in JSON config files, even when properly escaped
For API keys and certificates, prefer environment variables or dedicated secret management services
If secrets must be in JSON, implement proper access controls and consider encryption at rest

Transmission Security

Base64 encoding provides no security benefits on its own—it's encoding, not encryption
Always use HTTPS/TLS when transmitting JSON containing sensitive multi-line data
Consider field-level encryption for highly sensitive values within JSON payloads

Cross-Site Scripting Protection

Be cautious when deserializing and rendering user-provided multi-line content in web applications
Apply context-appropriate output encoding before rendering any stored JSON strings

Need senior JavaScript & AI engineers who pay attention to these details? Hire proven developers in days—not weeks.

How to Search Git Commit History

Chris — Mon, 21 Apr 2025 20:01:51 +0000

TL;DR – git log --grep="<pattern>" searches commit messages.

git grep <pattern> $(git rev-list --all) searches the code itself.

Add filters (--author, --since, -- path/) or context flags (-p, -S, -G) to zero‑in fast.

Modern repositories can hide tens of thousands of commits. Manually scrolling—or memorising hash IDs—wastes time you could spend shipping code.

Below is a toolkit of six repeatable search patterns that work in any project, whether it’s a fresh micro‑service, a sprawling monorepo, or a decade‑old SVN‑convert.

Why Bother Searching Your Git History?

Trace when a bug‑causing string first appeared.
Audit new licenses (e.g. "MIT").
Track feature toggles or API keys before release.

1 Search Commit Messages Only

# Case‑sensitive
git log --grep="facebook"

# Case‑insensitive + pretty output
git log --all --grep="facebook" -i --pretty="%h %ad | %s" --date=short

Tip: Combine multiple patterns with --grep and --invert-grep.

Search Code Changes (Pickaxe)

# Show commits that add or remove the string
git log -S"facebook"

# Regex version (‑G) – useful for variable names
git log -G"facebook_[0-9]+" -p

-S compares string counts between parent/child patches; -G runs a regex diff.

Once you've squashed the fix, branch, squash, and fork correctly before opening a pull request.

# Every revision, but only for *.js files
git grep "facebook" $(git rev-list --all) -- '*.js'

Add -n (line numbers) or -I (skip binaries) for speed.

Narrow the Search

# Flag           Purpose                     Example
--author         limit by committer          --author="you@company.com"
--since          date lower bound            --since="2024-01-01"
--until          date upper bound            --until="2024-12-31"
-- path/         specific directory          -- src/cli/
-i               case‑insensitive            -i

Combine freely:

git log --grep="facebook" --author=alice --since="2 weeks ago" -- src/

Quick One‑Liner Cheatsheet

# Search messages
alias glg='git log --all --grep'

# Pickaxe search w/ patch
alias gls='git log -S -p'

Save to ~/.gitconfig under [alias] for muscle memory.

And when you’re ready to ship, see our guide on automating your deploy for zero‑downtime releases.

Visual Alternatives

gitk --all --grep <pattern> – lightweight GUI.
VS Code → Source Control panel → Search Commits extension.
GitHub → repository → Insights → Community → Commits and filter.
Next up → branch, squash, and fork correctly • automate your deploy.

Common Pitfalls

Binary files – add -I (capital‑i) to skip.
Submodules – run in each submodule or use --recurse-submodules (Git 2.13+).
Large repos – prepend LC_ALL=C to speed regex; or restrict with -- path/.

That’s It—Happy Hunting

Spotted something outdated or have a faster trick? Open a PR—or better, join Gun.io and build with engineers who live in their terminal.

Pitch Comp Decided by Devs

Chris — Tue, 01 Nov 2022 15:51:52 +0000

Gun.io is holding a pitch competition, but instead of pitching to investors, the winner will be decided by pitching to the dev community. https://gun.io/pitch/

What are your thoughts?