Sed, a powerfull mini-language from the 70s

This would have been a good article if the author actually took the time to write out the article themselves, perhaps in their native language, rather than using a LLM to write it.

For a while my home had a Raspberry Pi 2B running FreeBSD 10 acting as a router-on-a-stick. When I lost SSH connectivity to it, I would instead use GNU screen as with a serial cable. For whatever reason, I could never get "full screen" TUI apps like vi and nano to display properly. To edit files (like pf.conf for firewall rules), I had to use sed to edit lines of the file. It was an interesting learning experience and perhaps a glimpse of how things used to be with green screen terminals. Shortly thereafter I switched over to a Beaglebone Green with OpenBSD 5 and never needed that workaround again.

For those of us using vim/neovim sed is something everyone had to learn, even if they did not realize it.

This is the true power of vim. Even now decades later the unix toolbelt holds up, and is still unmatched for productivity.

Vim is in the end just a small piece of the puzzle. You use small tools for your problem, mix and match.

Its kind of like functional programming. Compose and reduce.

Long ago, I bought the O'Reilly "Sed & Awk" book with plans to become a true unix guru.

Then I realized I already knew Perl (and Perl one-liners), so there it sat unused on the shelf.

Thanks for the blast from the past. SED led me to AWK, which led me to Perl, which lead me to Python. An interesting chain that brought me back to the interpreted languages like BASIC that I programmed in when I was a kid. Even though my formal training in college was Pascal and C.

I learned sed back in the day to show off. I wish I'd invested that effort in learning perl oneliners instead. For whatever reason I picked up enough awk along the way, and now that's what I tend to use if I ever need something beyond a simple substitution.

Just read this

https://sed.sourceforge.io/local/scripts/dc.sed.html

I prefer sam [1]. Unlike sed, it's not Turing complete, but it is far more elegant to my taste - consider this example from the article:

    :loop N; s/\n[[:space:]]\+/ /g; t loop; p

    x/(.+\n)*/ x/\n */ c/ /

Another example:

    N; h; s/\n/->/g ;p; g; D

    {
        1,$-2 x/./ {
            a/->/
            /./ t .
        }
        $-1 d
    }

Let's see how far we can get. Another example:

    N; h; s/\n/->/g; p; G; D

    {
        d
        1,$-2 x/./ {
            1,/./ x/.|\n/ {
                g/./ t $
                g/\n/ $ c/->/
            }
            $ c/\n/
        }
    }

The final example from the post is too long to have it here (15 lines). Here's just the sam equivalent for it:

    x/(.+\n)+|\n+/ {
        g/./ x/\n/ c/ /
        v/./ c/\n/
    }

What I have learned from this is that a tool with limited but well-chosen primitives is more convenient than a universal state machine.

(My examples may not be the exact same algorithms, since I do not understand (or need) sed concepts, but they do produce the same output.)

[1]: https://9p.io/sys/doc/sam/sam.html