Awesome-Rust-MachineLearning VS nushell

There’s an awesome-git list for a bunch of ML rust stuff not sure how up to date it is as well https://github.com/vaaaaanquish/Awesome-Rust-MachineLearning … not mine

I am looking for something like [Triton Inference Server](https://github.com/triton-inference-server/server) or [TFX Serving](https://www.tensorflow.org/tfx/guide/serving), but in Rust. I came across [Orkon](https://github.com/vertexclique/orkhon) which seems to be dormant and a bunch of examples off of the [Awesome-Rust-MachineLearning](https://github.com/vaaaaanquish/Awesome-Rust-MachineLearning)

There's also https://github.com/vaaaaanquish/Awesome-Rust-MachineLearning

I saw Awesome-Rust-MachineLearning. It have something replacements from Python.

Nushell?

https://github.com/nushell/nushell

Any thoughts on fish as compared to nushell [0]? It's similar to PowerShell in its philosophy and is also written in Rust.

[0] https://github.com/nushell/nushell

That or https://www.nushell.sh/ which seems to be more interesting as it could be an equivalent to PowerShell for Unix.

> In PowerShell, structured output is the default and it seems to work very well.

PowerShell goes a step beyond JSON, by supporting actual mutable objects. So instead of just passing through structured data, you effectively pass around opaque objects that allow you to go back to earlier pipeline stages, and invoke methods, if I understand correctly: https://learn.microsoft.com/en-us/powershell/module/microsof....

I'm rather fond of wrappers like jc and libxo, and experimental shells like https://www.nushell.sh/. These still focus on passing data, not objects with executable methods. On some level, I find this comfortable: Structured data still feels pretty Unix-like, if that makes sense? If I want actual objects, then it's probably time to fire up Python or Ruby.

Knowing when to switch from a shell script to a full-fledged programming language is important, even if your shell is basically awesome and has good programming features.

Maybe if the "popular" shells, but http://www.nushell.sh/ is looking better and better

Yeah agreed, especially now that PowerShell is available cross-platform.

Nushell[1] also seems like a promising alternative, but I haven’t had a chance to play with it yet.

[1]: https://www.nushell.sh/

I also discovered an existing discussion[1] related to this topic which includes a link[2] to a "helper to call nushell nuon/json/yaml commands from bash/fish/zsh" and a comment[3] that the current nushell dev focus is "on getting the experience inside nushell right and [we] probably won't be able to dedicate design time to get the interface of native Nu commands with an outside POSIX shell right and stable.".

[0] https://gitlab.com/RancidBacon/notes_public/-/blob/main/note...

[1] "Expose some commands to external world #6554": https://github.com/nushell/nushell/issues/6554

[2] https://github.com/cruel-intentions/devshell-files/blob/mast...

[3] https://github.com/nushell/nushell/issues/6554#issuecomment-...

Today I learned (after disappearing down a rabbit hole after reading the linked article) that it's actually possible to begin to use & benefit from nushell's structured data pipe feature without changing one's current shell.

Structured data pipes have always been my primary reason for keeping an eye on nushell's development but after looking at the project's documentation again today it all still seemed "too much initial effort with uncertain outcome".

Because I don't want to switch my shell (not because bash is good but because it's not a priority to justify the expenditure of effort), I just want to have structured data in pipes within bash!

Turns out it's as easy as:

* nu --commands 'ls | where size > 1MiB'

(Where `nu` is the nushell binary being called from your existing shell prompt.)

Or, as more complete flow of data example:

* echo "[1,2,3]" | nu --stdin --commands 'from json | to json' | cat

Now you can fit nushell within your existing workflow where ever it's useful enough for you--without needing to commit to changing your entire shell.

(And this isn't the only or necessarily the best way to arrange things for the communication with bash--there's "^" & "externals" & "command signatures" & "from ssv" etc too.)

And nushell does have some nifty tools such as `explore` with `:try` to interactively build a processing pipeline.

But this information doesn't seem to be documented anywhere in the "book" or other introductory material. It only seems to be documented in the help message of the `nu` binary--which I almost didn't even get as far downloading today.

But then I found the help text in the source, so decided to try it again: https://github.com/nushell/nushell/blob/fd4ba0443d01e67f6304...

If the structured data pipes is one of the main appeals for you, maybe try this approach out?