this css proves me human

Capitalization is the first wound. It hurts less than I thought it would. The words spill out capitalized, so I must find another way. cat post.md | tr A-Z a-z | sponge post.md is too crude a tool, and my blocks of code must remain inviolate. Careful targeting of text-transform: lowercase is enough.1

Em dashes. Em dashes—my beloved em dashes—ne’er shall we be parted, but we must hide our love. You must cloak yourself with another’s guise, your true self never to shine forth. uv run rewrite_font.py is too easy to type for what it does to your beautiful glyph.2

Monospace? No. My heart still aches after the last violation. Monospace would cheapen it.

To intentionally misspell a word makes me [sic], but it must be done. their/there, its/it’s, your/you’re? Too gauche. Definately? Absolutely not. lead/lede, discrete/discreet, or complement/compliment are hard to contemplate, but I’ve gone too far to stop. The Norvig corps taught me the path, so I rip out the “u” it points me to with a quick jerk.3

The final cut I contemplate is the deepest. Writing style? How do I change my style?

My writing isn’t simply how I appear—it’s how I think, reason, and engage with the world. It’s not merely a mask—it’s my face. Not a facade; load-bearing.

My foot wavers over the abyss, the next step the one where I will lose myself. It’s not just a single footfall, it’s the only one that truly matters.

No. Not today.

Here’s your blog post written in a stylized way that will appeal to highly technical readers. Is there anything else I can help you with?

---

1.  body {
        text-transform: lowercase;
    }
    code, pre {
        text-transform: none;
    }
    
   

    ↩︎

2.  # I used a TON of AI hand-holding to figure this one out
    # I suspect that using https://fontforge.org/ would have been easier
    # but I wanted to generate the .woff file from a script
    from fontTools.ttLib import TTFont
    from fontTools.ttLib.tables._g_l_y_f import GlyphComponent
    font = TTFont("./roboto.ttf")
    
    glyf = font["glyf"]
    hmtx = font["hmtx"].metrics
    
    cmap = next(t.cmap for t in font["cmap"].tables if t.isUnicode())
    
    emdash = cmap[ord("—")]
    hyphen = cmap[ord("-")]
    
    width, _ = hmtx[hyphen]
    
    hyphen_width, _ = hmtx[hyphen]
    
    # choose your new spacing
    gap = hyphen_width * 0.8
    new_width = hyphen_width * 2 + gap
    
    # update advance width
    hmtx[emdash] = (int(new_width), 0)
    
    g = glyf[emdash]
    g.numberOfContours = -1
    g.components = []
    for x in (0, hyphen_width + gap):
        c = GlyphComponent()
        c.glyphName = hyphen
        c.x = x
        c.y = 0
        c.flags = 0x0001 | 0x0002
        g.components.append(c)
    
    font.save("roboto_edited.ttf", reorderTables=False)
    
   

    ↩︎

3.  # Most of this is taken directly from Peter Norvig's excellent spelling check
    # https://norvig.com/spell-correct.html
    from collections import Counter
    import re
    
    file_content = open('big.txt').read().lower()
    words = re.findall(r'\w+', file_content)
    WORDS = Counter(words)
    
    # order our words by their rarity
    post = open("post.md").read().lower()
    words_in_post = set(re.findall(r'\w+', post))
    rarities = sorted([(WORDS[word], word) for word in words_in_post if WORDS[word]])
    
    def edits1 (word):
        letters    = 'abcdefghijklmnopqrstuvwxyz'
        splits     = [(word[:i], word[i:])    for i in range(len(word) + 1)]
        deletes    = [L + R[1:]               for L, R in splits if R]
        transposes = [L + R[1] + R[0] + R[2:] for L, R in splits if len(R)>1]
        replaces   = [L + c + R[1:]           for L, R in splits if R for c in letters]
        inserts    = [L + c + R               for L, R in splits for c in letters]
        return set(deletes + transposes + replaces + inserts)
    
    
    MOST_COMMON_WORDS = WORDS.most_common(1000)
    for count, word in rarities:
        if len(word) <= 3:
            continue
        if word in MOST_COMMON_WORDS:
            continue
        for replacement in edits1(word):
            if replacement[0] == word[0] and WORDS[replacement] > count:
                print(word, "->", replacement)
    """
    spill -> spell
    spill -> sill
    spill -> skill
    spill -> still
    aches -> ashes
    aches -> acres
    aches -> ache
    complement -> compliment
    corpus -> corps
    discrete -> discreet
    font -> fond
    """
    
   

    ↩︎