Anic: Faster than C, safer than Java, simpler than *sh

I like bash. Especially bash v4 brought some niceties, making it even more suitable for various non-trivial tasks.

I generally don't "upgrade" to Python or some "real" scripting language unless I really have to: bash is surprisingly concise and expressive. I've written programs and subroutines in bash that were much smaller than their idiomatic Python counterparts and I was surprised to discover that.

Bash is conceptually pretty safe and suits the functional mindset because in a large program you find you want to isolate each function the Unix way: byte streams. You pass in a stream (and args) and you get a stream out (and exit status). Thus, you end up making the functions quite pure and well off if you come from a functional background. Pure functions/shell scripts are rather safe and also parallelize pretty well.

If part of your program does something critical it's best to move it from a set of functions into a separate shell script. This gives you the same Unix stream API but also the benefit of process-level separation of data and environment. It simply enforces the Unix byte streams as the only way to talk between the caller and the callee.

And usually you can do this with only a few lines of code. Shell scripting can be ― and is ― intuitive. This is because processing files and streams, I/O, and parsing and mangling command lines and strings of words is pretty implicit in bash, which usually is very close to what you want to achieve in the end so you get down to the actual work pretty quick.

Having said that, I personally don't feel shellscripting is all that intuitive either.

I wouldn't feel the same way if it was a different sh than bash. For example, this is easy in bash:

    let total=0
    let n=10
    for ((i=0; i<n; ++i)); do
       if (( i % 2 != 0 )); then
           printf 'Odd: %.3d\n' $i
       fi
       let total+=i
    done
    echo "Total is: $total, average is $((total / n))"

Yes, indeed. You might also like Haskell and Clean that also do this.

> and parallelization of your code for you

And may soon do that as well.

It just comes off as odd at first because it's dealing with concepts that are actually pretty unique (to my knowledge at least) - streams and latches.

I really hope its a joke.

Of course, the real barrier to using this for real projects would be library support.

These claims leverage the fact that the fastest implementation in C is incredibly difficult to write. Usually we discard that difficulty when comparing languages, but as time goes on the costs of developing specific distributed, multi-threaded, and/or reliable systems in pure C becomes so outrageous that it stops making sense to ignore, so we start comparing against less correct implementations.

I find that kind of claim pretty annoying.

backslashes were chosen for a purely pragmatic reason; on virutally all keyboards, backslashes are very easy to type (requiring only a single keystroke). This is a handy property for backslashes to have because in ANI, you'll be typing them a lot!