Forem: Snappy Tools

How to Spot Every Change Between Two Versions of a Text (Without Reading Both Line by Line)

Snappy Tools — Tue, 14 Apr 2026 10:08:37 +0000

You just rewrote a paragraph. Or edited a config file. Or received a revised document from a colleague. Now you need to know: exactly what changed?

Reading both versions side by side is tedious and error-prone. You will miss things. Diff tools exist precisely for this — and you don't need to install anything.

What is a text diff?

A "diff" is a summary of the differences between two versions of a text. Originally a Unix command-line tool (diff), the concept is now everywhere: Git uses it to show code changes, Wikipedia uses it to show edit histories, and code review tools use it to highlight what changed between pull requests.

A diff shows you:

Added lines (highlighted in green)
Deleted lines (highlighted in red)
Unchanged lines (shown for context)

This makes it immediately clear what was added, removed, or modified — without reading everything word by word.

The algorithm behind it: LCS

Most diff tools — including this one — are based on the Longest Common Subsequence (LCS) algorithm. The idea is to find the longest sequence of lines that appear in both texts in the same order, and treat everything else as an addition or deletion.

For example, given:

Original:

The quick brown fox
jumps over the lazy dog

Modified:

The quick red fox
leaps over the lazy dog

The LCS finds The quick and fox in the first line, and the second line is unchanged. The diff reports:

brown → deleted, red → added
Second line: unchanged

Modern diff tools operate at the word level within changed lines (called "inline diff"), which makes edits even easier to spot.

When to use a text diff tool

Writing and editing:

Compare two drafts of an article or essay to review what your editor changed
Check if a client applied your suggestions correctly
Review changelog entries before publishing

Development:

Compare configuration files before and after a change
Review a file you received against your last known version when you can't use Git
Quickly audit what a script modified in a text file

Data work:

Compare two exports of the same data to find discrepancies
Spot added or removed rows in a TSV or CSV snippet

Inline vs side-by-side view

Most diff tools offer two display modes:

Inline view — both versions are shown in a single column, with additions and deletions interleaved. Easier to scan when changes are scattered across the text.

Side-by-side view — original on the left, modified on the right, with corresponding lines aligned. Better for seeing the shape of what changed at a glance, especially for longer documents.

Useful options: ignoring whitespace and case

Two options make diffs much more useful in practice:

Ignore whitespace — tabs vs spaces, trailing spaces, or re-indented code shouldn't count as meaningful changes. Most good diff tools let you strip whitespace before comparing so you only see structural edits.

Ignore case — useful when comparing text that may have been reformatted (e.g. all-caps headings → title case) or when casing differences aren't semantically important.

Try it in your browser

If you need to compare two texts right now, SnappyTools' Text Diff Checker runs entirely in your browser — nothing is sent to a server. Paste both versions, choose inline or side-by-side view, and see the diff immediately.

You can also:

Ignore whitespace or case with a single toggle
Copy the diff as plain text (with +/- prefix markers)
Use the "Try an example" buttons to see how it works before pasting your own text

No signup, no file uploads, no waiting.

SnappyTools builds free, fast, browser-based tools for developers, writers, and designers. No signup, no data uploaded.

From API to Spreadsheet: How to Convert JSON to CSV Without Writing a Script

Snappy Tools — Fri, 10 Apr 2026 10:06:23 +0000

You just hit a REST API. The response looks like this:

[
  { "name": "Alice", "role": "Engineer", "team": "Backend" },
  { "name": "Bob",   "role": "Designer", "team": "Product" },
  { "name": "Carol", "role": "Engineer", "team": "Frontend" }
]

Your stakeholder wants this in a spreadsheet. Right now.

You have two options: write a quick Python script, or use a browser tool that does it in two seconds. This post covers both — and explains what actually happens during the conversion so you understand the edge cases.

What JSON to CSV conversion actually does

A JSON array of objects maps cleanly to a CSV file:

Each object becomes a row
Each key becomes a column header
Each value becomes a cell

For the example above, the output is:

name,role,team
Alice,Engineer,Backend
Bob,Designer,Product
Carol,Engineer,Frontend

Simple when the data is flat. It gets interesting when objects contain nested structures.

The nested object problem

Most real API responses are not flat. Consider:

[
  {
    "name": "Alice",
    "address": { "city": "London", "country": "UK" },
    "tags": ["backend", "python"]
  }
]

You have two choices for how to handle address and tags:

Flatten (dot-notation headers):

name,address.city,address.country,tags
Alice,London,UK,"[""backend"",""python""]"

The nested address object becomes two columns: address.city and address.country. Each nested key gets a dotted path as its header. This makes the data fully tabular and works cleanly in Excel or Google Sheets.

Stringify (keep as JSON):

name,address,tags
Alice,"{""city"":""London"",""country"":""UK""}","[""backend"",""python""]"

The nested object stays as a JSON string in one cell. Less readable in a spreadsheet, but you can re-parse it later if needed.

Which to use? Flatten if you need to filter or sort by nested fields in the spreadsheet. Stringify if you just want to move the data somewhere and might re-process it later.

Doing it in Python (one function)

If you're already in a script:

import csv
import json

def flatten(obj, prefix=""):
    """Recursively flatten a nested dict with dot-notation keys."""
    items = {}
    for key, val in obj.items():
        full_key = f"{prefix}.{key}" if prefix else key
        if isinstance(val, dict):
            items.update(flatten(val, full_key))
        else:
            items[full_key] = val
    return items

def json_to_csv(data, output_path):
    flat = [flatten(row) for row in data]
    # Collect all unique headers across all rows
    headers = list(dict.fromkeys(k for row in flat for k in row.keys()))

    with open(output_path, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=headers, extrasaction="ignore")
        writer.writeheader()
        for row in flat:
            writer.writerow(row)

# Usage
with open("data.json") as f:
    data = json.load(f)

json_to_csv(data, "output.csv")

This handles:

Flat objects
Nested dicts (flattened with dot notation)
Missing keys (written as empty cells, not errors)

RFC 4180 — the CSV standard that trips people up

CSV sounds simple until a value contains a comma or a newline. RFC 4180 defines the rules:

Values containing commas, quotes, or newlines must be wrapped in double quotes
A literal double quote is escaped as two double quotes ("")
Each row ends with CRLF (\r\n) for maximum compatibility

Python's csv module handles this automatically. If you're writing a CSV by hand with string concatenation — don't. You'll hit edge cases.

The browser alternative

If you just need to convert a JSON blob right now — no terminal, no Python environment — paste it into SnappyTools JSON to CSV Converter. It runs entirely in your browser (no upload, no server), handles flatten vs stringify modes, and downloads a properly escaped RFC 4180 CSV file.

Useful when:

You're on a shared machine without a dev environment
You need to quickly check what a JSON structure looks like as a table before writing a script
You need to share the result with a non-developer immediately

Edge cases to handle in any conversion

Whether you're writing your own code or using a tool, watch for these:

Sparse data — not all objects have the same keys. The converter collects all unique keys across the entire dataset and uses them as headers. Objects missing a key get an empty cell.

Null values — null in JSON becomes an empty string in CSV (there's no CSV equivalent of null).

Boolean values — true and false become the literal strings "true" and "false".

Arrays of primitives — ["a", "b", "c"] doesn't map cleanly to a single column. Most tools stringify it. If you need it split across columns, you'll need a custom transform.

Large files — browser-based tools handle files up to several MB fine. For 50MB+ JSON, use Python or a command-line tool like jq.

Quick reference

Situation	Recommendation
Flat JSON array, quick share	Browser tool
Nested objects, need tabular output	Flatten mode
Need to re-parse later	Stringify mode
Automated pipeline	Python `csv` + `json` modules
50MB+ file	`jq` + shell redirection

JSON to CSV is one of those conversions that looks trivial and hides real complexity in the edge cases. Knowing when to flatten, when to stringify, and how CSV escaping works will save you from corrupted spreadsheets and confused stakeholders.

Flesch-Kincaid, Gunning Fog, and Why Your Writing Score Matters

Snappy Tools — Thu, 09 Apr 2026 10:06:37 +0000

You've probably seen a readability score mentioned in your CMS, SEO tool, or writing app. But what do numbers like "Flesch Reading Ease 62" or "Grade Level 9" actually mean — and should you care?

This guide explains the three most useful readability metrics, what scores to target, and how to improve yours.

What Is a Readability Score?

A readability score estimates how easy a piece of text is to understand. Instead of subjective feedback, it gives you a number based on measurable properties of your writing — mainly sentence length and word complexity (syllable count).

These scores were originally developed for newspaper publishers and government agencies who needed to match content to their audience. Today they're used by bloggers, UX writers, marketers, legal teams, and SEO professionals.

The Three Metrics You Should Know

1. Flesch Reading Ease (0–100)

The most widely known readability metric. Higher scores = easier to read.

Score	Level	Who can read it
90–100	Very Easy	5th grader
70–80	Easy	General adult audience
60–70	Standard	8th–9th grade — plain English target
50–60	Fairly Difficult	High schoolers
30–50	Difficult	College level
0–30	Very Difficult	Specialist / academic

Target: 60–70 for most web content. Popular blogs like Medium articles average around 65.

Formula:

206.835 − (1.015 × avg words per sentence) − (84.6 × avg syllables per word)

2. Flesch-Kincaid Grade Level

Same inputs as Reading Ease, but expressed as a US school grade level. A score of 8 means an 8th grader can read it comfortably.

Formula:

(0.39 × avg words per sentence) + (11.8 × avg syllables per word) − 15.59

Target: Grade 6–8 for blogs and web content. Grade 9–12 for professional reports.

3. Gunning Fog Index

Focuses on "complex words" — words with 3 or more syllables. It estimates the years of formal education needed to understand the text on first reading.

Fog Score	Readability	Example
6	Very easy	Tabloid newspapers
8	Easy	Novels, magazines
10	Standard	Most web content
12	High school level	Professional writing
14+	Difficult	Academic papers
17+	Very difficult	Too complex for most readers

Target: 10–12 for most professional writing. Scores above 17 should be a red flag.

Real-World Benchmarks

Here's how well-known publications score:

The Sun (UK tabloid): Flesch ~65, Grade 6
The Guardian: Flesch ~55, Grade 9–10
Harvard Business Review: Flesch ~45, Grade 12–13
Nature (science journal): Flesch ~25–35, Grade 15–17

The Plain English Campaign recommends targeting Flesch 60–70 for government and health communications — writing that a 13-year-old can understand.

Why This Matters for SEO

Google doesn't directly score your readability. But readable content gets better engagement:

Lower bounce rates — people don't leave immediately if they can actually read the content
Longer time on page — a signal Google uses to assess content quality
More backlinks — clear, useful writing gets referenced more
Voice search — conversational, simple language matches how people speak queries

Yoast SEO flags readability as an SEO factor for exactly these indirect reasons.

5 Ways to Improve Your Score

Shorten sentences — aim for 15–20 words on average. If a sentence runs past 30 words, split it.
Prefer shorter words — "use" instead of "utilise", "start" instead of "commence", "show" instead of "demonstrate". Every syllable counts.
Cut passive voice — "The report was written by the team" → "The team wrote the report". Fewer words, clearer meaning.
Break up paragraphs — no more than 3–4 sentences for web content. White space is readability.
Avoid unnecessary jargon — define terms when you must use them. Your readers may not share your domain knowledge.

Check Your Writing Now

If you want to see your actual scores, paste any text into the SnappyTools Readability Checker. You get Flesch Reading Ease, Flesch-Kincaid Grade Level, and Gunning Fog Index instantly — no signup, no limits, and your text never leaves your browser.

There's also a score reference table built into the tool so you can interpret your results immediately.

Do you aim for a specific readability score in your writing? Let me know in the comments — I'm curious whether writers actively target these metrics or just write naturally.

Stop serving unminified CSS — a 2-minute fix for faster pages

Snappy Tools — Mon, 06 Apr 2026 13:21:30 +0000

Every byte your browser downloads before rendering a page costs time. CSS is one of the biggest culprits — and one of the easiest to fix.

What CSS minification actually does

Minification strips everything from your stylesheet that the browser doesn't need to parse it:

Comments — /* This is a comment */ → gone
Whitespace — indentation, blank lines, spaces around { } ; → gone
Trailing semicolons — the last ; in a rule block is optional in CSS → gone

Here's a before/after on a typical stylesheet:

Before (287 bytes):

/* Navigation styles */
nav {
  display: flex;
  align-items: center;
  padding: 16px 24px;
  background: #ffffff;
  border-bottom: 1px solid #eee;
}

nav a {
  color: #333;
  text-decoration: none;
  font-weight: 600;
}

After (122 bytes):

nav{display:flex;align-items:center;padding:16px 24px;background:#ffffff;border-bottom:1px solid #eee}nav a{color:#333;text-decoration:none;font-weight:600}

Same result in the browser. 57% smaller.

Does minifying break anything?

No — with one ancient exception. CSS hacks written for IE6/7 using deliberately malformed syntax can be affected. You're not writing those. Modern CSS is safe to minify.

The real gains come from combining minification with compression

Minifying alone gets you 20–40% smaller files. But the bigger win is that minified CSS compresses better with gzip or Brotli, because it has less varied content. A file that minifies from 100 KB to 65 KB might then compress to 14 KB — a 86% total reduction from the original.

Most hosts (Cloudflare, Vercel, Netlify, nginx with gzip on) handle the compression automatically. You just need to supply the minified file.

When to beautify

The opposite need comes up regularly: you inherit a minified stylesheet and need to read it, or you copy CSS from a DevTools panel and it's all on one line.

Beautifying expands it back out with proper indentation so it's human-readable again. Useful for:

Debugging third-party CSS
Reading CSS from browser DevTools
Formatting CSS generated by a preprocessor

Quick tool

If you need to minify or beautify CSS without installing anything, SnappyTools has a free browser-side minifier and beautifier — paste your CSS, pick a mode, and see the file size change instantly. Nothing is uploaded; it all runs locally in your browser.

In your build pipeline

For production use, you'll want minification automated:

Vite / Rollup — enabled by default in production builds (uses esbuild).

webpack with css-minimizer-webpack-plugin:

const CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
module.exports = {
  optimization: { minimizer: [new CssMinimizerPlugin()] }
};

PostCSS with cssnano:

npm install cssnano postcss-cli
echo '{"plugins": {"cssnano": {}}}' > postcss.config.json
npx postcss styles.css -o styles.min.css

Simple shell one-liner (for quick jobs without a build tool):

# Paste to your CSS minifier of choice, or use the online tool above

The online tool is best for one-off jobs or when you're working outside a build pipeline — checking a snippet, cleaning up a file you inherited, or just curious how much space you'd save.

Minification is one of those 10-minute tasks that pays back every time someone loads your page. Worth doing.