I’ve been using fish (with starship for prompt) for like a year I think, after having had a self-built zsh setup for … I don’t know how long.

I’m capable of using awk but in a very simple way; I generally prefer being able to use jq. IMO both awk and perl are sort of remnants of the age before JSON became the standard text-based structured data format. We used to have to write a lot of dinky little regex-based parsers in Perl to extract data. These days we likely get JSON and can operate on actual data structures.

I tried nu very briefly but I’m just too used to POSIX-ish shells to bother switching to another model. For scripting I’ll use #!/bin/bash with set -eou pipefail but very quickly switch to Python if it looks like it’s going to have any sort of serious logic.

My impression is that there’s likely more of us that’d like a less wibbly-wobbly, better shell language for scripting purposes, but that efforts into designing such a language very quickly goes in the direction of nu and oil and whatnot.

Fish is great.

I used nushell for a good 6 months, it was nice having structured data, but the syntax difference to bash which I use for my day job was just too jarring to stick with.

Fish was (for me) the right balance of nice syntactic sugar and being able to reasonably expect a bash idiom will work.

I’m an absolute Linux tard, so it’s hilarious to me trying to read and understand most of these comments

I love Nushell, it’s so much more pleasant for writing scripts IMO. I know some people say they’d just use Python if they need more than what a POSIX shell offers, but I think Nushell is a perfect option in between.

With a Nushell scripts you get types, structured data, and useful commands for working with them, while still being able to easily execute and pipe external commands. I’ve only ever had two very minor gripes with Nushell, the inability to detach a process, and the lack of a -l flag for cp. Now that uutils supports the -l flag, Nushell support is a WIP, and I realized systemd-run is a better option than just detaching processes when SSHd into a server.

I know another criticism is that it doesn’t work well with external cli tools, but I’ve honestly never had an issue with any. A ton of CLI tools support JSON output, which can be piped into from json to make working with it in Nushell very easy. Simpler tools often just output a basic table, which can be piped into detect columns to automatically turn it into a Nushell table. Sometimes strange formatting will make this a little weird, but fixing that formatting with some string manipulation (which Nushell also makes very easy) is usually still easier than trying to parse it in Bash.

Why not parse ls (and what to do instead)?

That looks a lot like PowerShell

Nushell is great, I should use it again. Gave up on it after I wrote a thing for converting fish completions to their autocomplete system for it and their internal autocomplete didn’t perform anywhere nearly adequately.

I’ve used nushell for several months, and it really is an amazing shell

It feels more like an actual language than arcane runes, and I can easily makes chains and pipelines and things that would be difficult in bash

Additionally, it makes a pretty good scripting language

Looks like it’s taken a page from PowerShell in passing structured data rather than just text.

Nushell looks cool but I prefer to stick with the POSIXes so that I know my scripts will always work and syntax always does what I expect it to. I use zsh as a daily driver, and put up with various bashes, ashes, dashes, that come pre-installed with systems I won’t be using loads (e.g. temporary vms).

(…) 'cause it was quarter part eleven

on a Saturday in 1999

🎶🎶

To answer your questions, I work on the Bash, because it’s what’s largely used at work and I don’t have the nerve to constantly make the switch in my head. I have tried nushell for a few minutes a few months ago, and I think it might actually be great as a human interface, but maybe not so much for scripting, idk.

I like nushell, but I love xonsh. Xonsh is the bastard love child of Python and Bash.

it can be thought of as:

• try this statement in Python
• if there’s an exception, try it in bash.

Now, that’s not a very accurate description, because the reality is more nuanced, but it allows for things like:

for file in !(find | grep -i '[.]mp3^'):
    file = Path(file.strip())
    if file != Path('.') and file != file.with_suffix('.mp3'):
    mv @(file) @(file.with_suffix('.mp3'))

Now, there are things in there I wouldn’t bother with normally - like, rather than using mv, I’d just use file.rename(), but the snippet shows a couple of the tools for interaction between xonsh and sh.

• !(foo) - if writing python, execute foo, and return lines
• @(foo) - if writing sh, substitute with the value of the foo variable.

But, either a line is treated in a pyhony way, or in a shelly way - and if a line is shelly, you can reference Python variables or expressions via @(), and if it’s Pythony, you can execute shell code with !() or $(), returning the lines or the exact value, respectively.

Granted, I love python and like shell well enough, and chimeras are my jam, so go figure.