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.
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.
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
In sam, the equivalent is:
x/(.+\n)*/ x/\n */ c/ /
It reads like this: loop over paragraphs of non-empty lines, loop over newline followed by spaces, replace with a single space. It's surprisingly close to SQL in its eloquence.
Another example:
N; h; s/\n/->/g ;p; g; D
In sam, a rough equivalent would be
{
1,$-2 x/./ {
a/->/
/./ t .
}
$-1 d
}
Again, it's readable from top to bottom: from the first line to the second from the end, loop over each symbol, put "->" after it and copy the next symbol next to it; delete the last line.
Let's see how far we can get. Another example:
N; h; s/\n/->/g; p; G; D
In sam, a rough equivalent would be:
{
d
1,$-2 x/./ {
1,/./ x/.|\n/ {
g/./ t $
g/\n/ $ c/->/
}
$ c/\n/
}
}
It reads like this: delete the whole thing; from the first line to the second from the end, loop over each character; on each iteration, from the first line to the next character, run an inner loop over each character or newline; if it's a character, put it at the end; otherwise, put "->" at the end; once the inner loop is done, put a newline at the end.
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/
}
It reads like this: loop over paragraphs of non-empty lines or sequences of newline characters; if it has any symbol (that is, it's a paragraph), replace each newline symbol with a space; if it doesn't have a symbol (that is, it's a sequence of newline symbols), replace it with a single newline.
What I have learned from this is that the right concept, however limited (and sam is far from being universal), is a better tool than a pure 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.)
https://www.grymoire.com/Unix/Sed.html
Then I realized I already knew Perl (and Perl one-liners), so there it sat unused on the shelf.
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.
Another example:
In sam, a rough equivalent would be Again, it's readable from top to bottom: from the first line to the second from the end, loop over each symbol, put "->" after it and copy the next symbol next to it; delete the last line.Let's see how far we can get. Another example:
In sam, a rough equivalent would be: It reads like this: delete the whole thing; from the first line to the second from the end, loop over each character; on each iteration, from the first line to the next character, run an inner loop over each character or newline; if it's a character, put it at the end; otherwise, put "->" at the end; once the inner loop is done, put a newline at the end.The final example from the post is too long to have it here (15 lines). Here's just the sam equivalent for it:
It reads like this: loop over paragraphs of non-empty lines or sequences of newline characters; if it has any symbol (that is, it's a paragraph), replace each newline symbol with a space; if it doesn't have a symbol (that is, it's a sequence of newline symbols), replace it with a single newline.What I have learned from this is that the right concept, however limited (and sam is far from being universal), is a better tool than a pure 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