...has not yet happened, but with every release my trust in the project diminishes, and I'm currently in the process of slowly rebasketting my eggs.
When I look at software I want to start using, what matters most to me is not really where it's at currently. I have 11-ish forks; patching in currently missing features and “configuration via source code” is something I'm very comfortable with. What I value most, instead, is how much can I trust the project.
What will it grow into? Will it keep a reasonable scope? Do my ideologies align with the author's ideologies of what this program / this genre of program should be like? Do they value quality over quantity? And of course the dreaded: how much ai is the project using?
A reassurance I get to have with well-scoped projects is “at the very worst, I'll be able to hackily maintain this for myself”.
Don't let Grey hear about this, but a part of my excitement with vellum is that even if he burns out on it, the foundation is still so amazing that I'll be able to keep it running and maybe implement some features I want along the way.
I'm nowhere near as talented as him; I wouldn't be able to maintain the project for others, or to keep it moving significantly, but I can be sure that the worst case scenario is not that bad of a case scenario.
I'm close to saying that this sort of thing is required when getting into any project, but I do realize how insane that sounds. Often times almost any project is “too big to fail” so to speak — you don't have to worry about the entire rust programming language collapsing when getting into it; too much of the world relies on it, and at least some forces will make sure it continues to be good.
Rust being fairly uncollapsable is in large part due to how much friction there is in getting something added or changed about the language. Some very smart people will bikeshed a tiny change for years without you ever needing to bash your head into it.
But you, as a project lead, can take a different direction and let the opposite situation happen: “it's too big, and therefore it fails”.
Nushell has a tui inside of it called explore — it lets you interactively explore data that you got from a bunch of different possible formats; digging into a possibly very nested structure that would be very hard to understand in, say, an editor.
A tui, huh! That's a pretty big feature. But makes a lot of sense for a very data-explorative language 😌
The amount of formats supported is pretty staggering; but thanks to rust, a lot of them are probably just some serde (I assume), so the project doesn't need to do that much to support each format.
Big, but reasonable. Good, even. BLAMMO nushell has a regex tui now.
WHAT??!
You just have a regex101-like tui as part of core??
Not like a plugin or anything, but as a straight up part of the language?
How good is it? About as good as you would imagine, but better than I'm making it sound. But still, holy shit that's a pretty big undertaking.
Even just all the various hotkeys you would want to have there is quite a bit of startup development cost; then, a ui for interacting with text is one of those things that will collect niche bugs over time, for you to maintain.
Continuing the same topic: you can make tuis IN nushell. You heard me. Something that is usually, and should be a whole ordeal, you can express in your shell code. It is this change that really changed my medium concernment into a high one. You do not get to “oh and btw...” the ability to make tuis into your language. Into, again, core; not even std.
And in the most recent release, which was massive as usual, I saw a new capability: you can generate nushell completions from a bunch of different formats, including --help pages.
I. am. out.
--help is not some super standardized format you can rely on. Sure, it's often similar, but by definition you can put literally anything into the --help page of your program and it'll be valid.
So obviously there will be many cases where that generator doesn't work. Over years, just how many bandaid fixes will this feature have to get?
And if none/few, what's the point of having it?
I'm providing quite few examples, but they are examples for a reason. They are simply what stands out in a sea of terror that I feel when reading yet another release note. They are consistently inhumanly massive.
I like to think of nushell as “a programming language with a really good repl”, not a shell. I think by taking it this way, you get to enjoy nushell more than you would otherwise — what nushell is truly good at is the programming language side, not so much the shell side.
I am also talking about interactive use of course, but my bigger point is that a shell has a pretty well defined job: it's glue for external commands.
It's an environment where you can, fairly concisely, define logic for how the standard input/output streams are handled, you work with file descriptors sometimes, it's about signals, background jobs and disowning them — all that stuff.
The actual behavior is stored elsewhere for the most part — within external commands.
What nushell is most good at, is essentially providing external commands; but to make them as good as they are, it sacrifices the shell parts. Which would be a valid tradeoff to make mind you: if nushell presented itself as a “programming language with a really good repl”, that would be an amazing approach!
But it made its scope massive: an interactive shell you are implied to make your main, AND a quite unique programming language on top of that. It's too big of a task! So once you add extra bullshit on top of that already massive goal, my only question becomes: who's going to maintain all of this? I think we unfortunately already know the answer — AI. The nushell project is already a little concerningly ai-positive; it walks on my personal line of comfort. And with so much code, implementing features that strongly imply “we're not even close to done”, nushell will necessarily have to be maintained with ai. It's an impossible workload otherwise.
And plainly put, why would I use that? Why would I not put my soul into another project, which I'm sure won't lose its heart, and will keep its priorities solid?
What's really heartbreaking to me, is that I've had a fantacular experience with the people of nushell. The maintainers are wonderful, kind, and smart people; they've patiently helped me many times, and heard some of my feature requests. So it's so sad to see them fortnite towering to their own demise 😔
“Sure it's a little hectic right now, but once it gets to stable it's gonna smoothen out” — I hear your understandable conclusion, but I don't think my reaction is due to a lack of experience with growing projects.
Again, I'm the eleven forks girl!
A lot, maybe even most of the projects I use are undercooked and actively growing:
they sometimes break my config, other times they break my patches, but it's worth it for the project to improve!
I'm still human of course: it's a little annoying. But I'm known to say that breaking changes are good and that a lot of software turns into a swampy puddle due to the fear of incrementing a particular number 🙄
The difference is that none of those projects grow as scarily as nushell. Hell, I could sum multiple of them together and they still won't come close to the tinyness of the scrollbar when you try to read a nushell release note. This cannot be sustainable. Nushell feels like a startup that survives entirely on investments, only to pop once those run out.
Would you be foolish in not trusting my warning?
Realistically I'm overreacting and instead of trying to go for “no nushell whatsoever at all”, I can simply reduce the circle of tasks that I use nushell for.
But what tasks, specifically? The nushell project already clearly showed to me its lack of solid priorities, I'm not so sure I can be certain that some parts will always remain super solid, and only some other parts will be questionable / flimsy.
As far as I see it, the ai-maintained parts that are meant to stay good, will be, well, ai-maintained. Which is curiously even worse than vibecoded.
You, unlike me, might manage the more reasonable reduction of use, rather than a complete rejection; But I would rather put all of my eggs elsewhere; somewhere, where the end of the tunnel is exciting and huggable, not terrifying.
what's next?
I already have some buy-in with nushell, so I've been thinking how to replace its usecases with other languages and tools. I learned nushell as a middleground between fish and rust: one is really fun but limited in what you can do in it; the other lets you do anything you'd ever want, but it's not going to be fun. The hard parts will be easy, but the easy parts will be annoying.
A useful distinction I like to make, is that there are fun and serious languages. If you treat a fun language as a serious language, you'll experience pain. Conversely, if you treat a serious language as a fun language, you also will. But if you categorize them appropriately, and use the right tool for the right job, you'll have an awesome time :D
What I'm saying is don't write an entire codebase in python, and don't write a program you don't care about the edgecases of in rust.
crystal
After a year long pause, I finally came back to learning my favorite programming language: crystal.
Like nushell, it is the fun type of programming language, but it's compiled and more strictly typed; also, more capable altogether. It has less “stuff” in it, but more goodies, if that makes any sense.
I'm going to be using crystal to cover a lot of what nushell is currently doing for me: there are some nushell scripts that I wrote where I underestimated just how serious they actually are — of course, experiencing pain.
By all accounts they should be written in a compiled language, but when my only other option was rust — NAH! that's entirely too much.
With crystal though? Just right :D
Part of the benefit of using a shell to write a program is that it'll have way more convenient interaction with external command calls, compared to a full-on programming language. But crystal has a syntax sugar for calling external commands that may make it a lot less painful to write an external-heavy program in! Yet thanks to the higher strictness, I'll be able to ensure a lot more invariants ahead of time.
Crystal makes me feel a lot more relieved to put eggs inside of (???), too. All of my interactions with the maintainers have been very positive, but as I already alluded to, that's not the main deciding factor; one specific situation really filled me with hope.
I was going through the String docs and they were kinda ahh in some parts. I'm new to the project, I'm not sure what the due process is like in contributing something. Do I... just open a pr? Or is there more beurocracy than that? Is a pr from a noob even welcome? How about I ask that on the crystal discord!
The response I get from a member of the core team is:
it's mostly open to humans :)
Now, I'll allow myself some creative interpretation, and read it as “it's mostly open (to only humans)” instead something more vague. And this really confirms that I can feel safe putting my heart into the project. Contributing not just code to it, but my soul, too.
large buy-in
There is one aspect of nushell I love particularly much, and it was a bit of a challenge to figure out how to avoid relying on: the nuon data format.
It's really spectacular 😭❗ it's the data format. The idea is very simple: json superset with much more permissive syntax: you don't have to "" keys or values, which makes it actually viable to use for config.
Wait... I feel like I've heard this somewhere before...
You might be used to seeing yaml in this kind of format:
customCommands:
- key: <c-u>
context: global
command: "create-patch-file.fish {{.Form.Filename}}"
description: "Write clipboard into a patch file"
output: none
prompts:
- type: input
title: "Enter patch filename"
key: Filename
suggestions:
command: "list-patch-files.fish"
Spaces instead of tabs enforced by the spec, weird idea of an aligned - expressing... something? Indentation specifying level as if that's a good idea, etc.
But ignoring a bunch of the other atrocities of yaml, it is at the end of the day a json superset where you don't have to quote keys or values.
So I can choose to write yaml the more reasonable way, and then the only difference between it and nuon, is the required commas (which I'm alright sacrificing):
{
customCommands: [
{
key: <c-u>,
context: global,
command: "create-patch-file.fish {{.Form.Filename}}",
description: "Write clipboard into a patch file",
output: none,
prompts: [{
type: input,
title: "Enter patch filename",
key: Filename,
suggestions: { command: "list-patch-files.fish" }
}]
},
]
}
Matter of fact, why haven't I chosen to write yaml this way earlier! It's so much more reasonable!
And so, since crystal has built in yaml support, my love for nuon is now essentially solved 😌
janet
A lot of my nushell is scripts or things that can be painlessly rewritten into whole ahh (compiled) programs.
But there still remain some usecases where an interpreted language is really helpful.
For example the way that I extract the id of a particular niri window, is a combination of fish where I inject nushell code into a nu -c '…' on runtime, to filter out all windows.
An interpreted language that I had in my backpocket but never considered, because it was suggested to me by a friend who likes to suggest unreasonably niche options, is janet.
Turns out it's reasonable after all! I've been reading the book on it, and the author really popped off :D such a fun read!
But aside from fun, it let me discover that the language itself is very good. It feels like lua done well: nice, capable standard library that doesn't turn massive; stored in a simple and small language, that doesn't hit you with a rock on every step.
And if you want more power, you can easily install
1
the batteries-included library called “spork”, which has a bunch more things (like json support).
Best thing about it? The startup time (when interpreted) is incredibly quick — almost as fast as a compiled crystal program. And you can also compile janet if you really want to! Looks like I finally found an interpreted language that is both fast and good 😌 yay
explore
The only thing left really, is how convenient nushell's explore is for looking through data. I feel nudged to keep nushell for just that, but ughhhhhh.
You see, I currently fork nushell for a more performat configuration injection. If I only ever open nushell interactively, my fork is no longer needed.
But ☝️ I still need to maintain my nushell config — the colors for values, hotkeys, etc.
And those will keep changing and annoying me for at least a while, if not indefinitely.
I refuse to read any more nushell release notes, so how do I discover that something changed and is therefore broken?
Well, bashing my head into the issue when I'm doing something else, and then ctrl+fing the release notes (now multiple) for how I think the change will be worded. And then I fix it.
Ugh idk, this just doesn't sound particularly worthwhile. Too big of a hammer for too narrow of a usecase.
Part of why I learned nushell, is to essentially replace jq.
I never ended up finishing learning it, but know from my good friend that it's actually awesome and really powerful. As an extra bonus, it's concise, which is wonderful for interactive use.
Secondly, jq is not the only thing that exists: it inspired a bunch of other …q programs, for you to use the same (or similar) syntax to filter out data — so if I were to finish learning jq, that learning wouldn't be wasteful.
Then I create myself a simple ui, where I type in a jq query, and on every character that query runs on the input that I gave it.
Essentially, an interactive jqer!
I'll be able to, turn by turn, input queries to look at the specific levels that I'm interested in.
I can easily extract only all toplevel keys, for example (I would be shocked if not); then after getting that overview, I can continue to build out the query to extract the information I care about.
And neatly, at the end, once I press enter — the query is blammoed into my clipboard, for me to use in the script I'm probably building.
There might already be some existing programs that do this exact thing, and I might look at them, but there's a big chance they overcomplicate things or do things Wrong™ where me just making my own will straight up spend less of my effort and sanity. We'll see.
Then for the formats for which a …q doesn't exist, I could easily create a rust program that loads in a bunch of serdi (lol), taking in input and converting it to json — so that I can then jq that.
I'd specify the input format with a flag, and call the program from, like in nushell :D
And here I go! All nushell usecases solved :D
footnotes
1
It's literally just in the arch repo as janet-spork; I wouldn't be too surprised if just installing it makes it automagically work with no extra effort on your part, but I'll need to see if that's the case as I continue to learn the language.