This article touches on a problem, that I don’t know good solution to. One that is especially important for tools related to security. Trying to put it in words:
Yesterday’s defaults may not be good today’s defaults. (In case of security, this may be old algorithms becoming defeated, and new ones being invented. In other cases, it may be because the tool and its usage patterns are now better understood than before.) To make a tool more user friendly (including safer to use), the tool’s defaults should be changed to new ones. But there are scripts using the old defaults out there in the wild (a.k.a. backwards compatibility). Is there no way out, other than keeping the old flags, and watching the tool become an ancient artifact? (see dd, etc.)
Now that I think of it, it feels like this is probably the same problem as API versioning. If yes, could some known approaches to API versioning be reused for command-line tools?
Some more thoughts that come to my mind:
Are we doomed to struggling with troublesome command-line interfaces like those of gpg, git, dd, etc.? Now that I think of it, Oil Shell seems to be at least one ambitious experiment at breaking the status quo in case of bash. Maybe that will tell us something more about the problem space when it gets completed?
Do you know of any command-line tool, where a new, redesigned interface was introduced successfulky, more than once?
This touches on implicit vs explicit behaviors. Everybody loves implicit behaviors. Especially in their GitHub marketing readme. See how easy it is to do this thing! But then it becomes harder to revise later. If you make the user tell you what they want, every time, there’s less misunderstanding. But then they write their own scripts, and then you’re even more locked into supporting old options.
Very interesting observation. Just to be clear, in my eyes it is still more of a related thing (as you wrote, “touches on”), than an answer to my questions. Also, from what you write, it sounds to me as if implicit behaviors were kinda “bad”; personally, from a user perspective (though not necessarily script-writer one - so, maybe, plumbing vs. porcelain again?), when the implicit (default) behaviors are good, I would keep arguing it is actually a “good” UI - by which I mean the kind where you don’t even realize it’s there (as in good GUI - the best ones are those where you don’t even think there’s any UI - it “just works”, “just does what I thought it would”). Anecdotally, this reminds me of a wiki-like website I built for a group of friends for collecting songs lyrics once; I put quite some effort in it, and then heard one friend call it “just a simple website” when talking to another. I felt offended at first (hey, I put so much effort in it, and you call it simple!); it took me a while to realize this was the ultimate praise, as it meant they felt it was simple to use.