You're the one who offered up that code as an example in the first place, to prove your point about bash being really great for people who don't want to bother reading documentation.

Being open source doesn't magically make your code great or efficient or bug-free or easy and irresistible for millions of eyeballs to examine and audit (in spite of what ESR's fallacious "Linux's Law" might claim), or obligate anyone to complement it or use it or take it and run with it.

https://en.wikipedia.org/wiki/Linus%27s_Law

If you make your code open source, then post links to it in public forums, right after bragging about only reading the language documentation a couple of times, you'd better get over being thin skinned about criticism.

I'm not criticizing your code, or your decision to open source it, or which license you chose, or your pride in only reading the documentation twice, or your decision to cherry pick and share that script as the best example you could come up with of bash's superiority. I'm criticizing your decision to write the code in bash instead of Python.

Can you at least please answer this one simple question: Name one thing about that code that is easier in bash than in Python?

>I've written literally thousands of lines of shell scripts (maybe even 10k+) across dozens of scripts over the years and I've only really looked at the docs a couple of times. Of course I'm Googling various syntax things that are humanly impossible to remember, but I never once really sat there and combed through all of the docs or even read a book on Bash.

At least you admit 1) you've only really looked at the docs a couple of times, and 2) bash syntax things are humanly impossible to remember.

Have you ever written any 10k+ line bash scripts? No, because it doesn't scale (and machine generated configure scripts don't count). I have a 16,078 line Python script in my emacs buffer right now that I wrote over more than a decade (which is just one facet of a big system written in many other languages).

My point (which is just a corollary of JWZ's Law of Software Envelopment and Greenspun's Tenth Rule) is that programs always grow over time, and you never realize how big and complex your programs are going to grow or how far they're going to evolve when you first write them.

So never assume you can get away with using a language that's so lame it has to call out to two other different languages just to perform simple string manipulation and arithmetic.

Good grief, even TCL can perform string manipulation and arithmetic without forking a bunch of new processes.

You should invest more time using languages with docs you can actually read, and with syntax you can actually remember. You might like it.

https://en.wikipedia.org/wiki/Jamie_Zawinski#Principles

>Zawinski's law of software envelopment (also known as Zawinski's law) comments on the phenomenon of software bloating with popular features:

>Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can.

https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule

>Greenspun's tenth rule of programming is an aphorism in computer programming and especially programming language circles that states:

>Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.