Slashdot Mirror
Take This GUI and Shove It
snydeq writes "Deep End's Paul Venezia speaks out against the overemphasis on GUIs in today's admin tools, saying that GUIs are fine and necessary in many cases, but only after a complete CLI is in place, and that they cannot interfere with the use of the CLI, only complement it. Otherwise, the GUI simply makes easy things easy and hard things much harder. He writes, 'If you have to make significant, identical changes to a bunch of Linux servers, is it easier to log into them one-by-one and run through a GUI or text-menu tool, or write a quick shell script that hits each box and either makes the changes or simply pulls down a few new config files and restarts some services? And it's not just about conservation of effort — it's also about accuracy. If you write a script, you're certain that the changes made will be identical on each box. If you're doing them all by hand, you aren't.'"
If you write a script, you're certain that the changes made will be identical on each box.
One little mistake in the script and you fuck up the whole organization.
RIP America
July 4, 1776 - September 11, 2001
I think the author might not fully understand who most admins are. They're people who couldn't write a shell script if their lives depended on it, because they've never had to. GUI-dependent users become GUI-dependent admins.
As a percentage of computer users, people who can actually navigate a CLI are an ever-diminishing group.
Am I part of the core demographic for Swedish Fish?
What would be nice is if the GUI could automatically create a shell script doing the change. That way you could (a) learn about how to do it per CLI by looking at the generated shell script, and (b) apply the generated shell script (after proper inspection, of course) to other computers.
The Tao of math: The numbers you can count are not the real numbers.
There are more and more small businesses (5, 10 or so employees) realizing that they can get things done easier if they had a server. Because the business can't really afford to hire a sysadmin or a full-time tech person, its generally the employee who "knows computers" (you know, the person who has to help the boss check his e-mail every day, etc.) and since they don't have the knowledge of a skilled *Nix admin, a GUI makes their administration a lot easier.
So with the increasing use of servers among non-admins, it only makes sense for a growth in GUI-based solutions.
Taxation is legalized theft, no more, no less.
Config files are one of the problems with linux. Most of them are far too hard to parse and modify so there aren't any GUI tools to do so. For example, how do you change the PATH in linux through the GUI? As far as I know there is no way. In windows it is (fairly) simple.
Of course there's no reason why you can't have the best of both worlds - every program can be abstracted into a CLI and GUI on top of the same base library.
I disagree. The "great" GUIs teach new users that they don't need a CLI, and many of them will never proceed past the point-and-drool stage, but expect a GUI app for anything they do.
When push comes to shove, a single line of awk or perl can easily do what half an hour of GUI clicking can't. And there's no way for a GUI to prepare you for perl or awk, only distract you from learning them.
This is also a problem with Max OS X Server. Apple builds their services from open source products and adds a GUI for configuration to make it all clickable and easy to set up. However, many options that can be set on the command line can't be set in the GUI. Even worse, making CLI changes to services can break the GUI entirely.
The hardware and software are both super stable and run really smoothly, so once everything gets set up, it's awesome. Still, it's hard for a guy who would rather make changes on the CLI to get used to.
Help I'm a rock.
I find it rather disturbing the UNIX ideal that sysadmins should be programmers. The opinion seems to be that it is perfectly ok for someone to need to do a fair bit of programming work to solve a system problem. Ok but the thing is programming and systems administration are not identical skills any more than say being a musician and being a recording engineer are. They are related, but proficiency in one is not the same as the other. I know more than a few programmers that are abysmal at system administration, and I know sysadmins that can't program. There is nothing wrong with this.
While I realize a simple (emphasis on simple) script isn't quite the same thing, this attitude smacks of the "People should just get down and code what they need," thing. No, not really. Not everyone should have to learn that skill, and you could well be excluding people you want by requiring it.
Also there's the simple matter that GUIs work better for unfamiliar situations. While it might be easy to just say "Well a good admin should know about this," that is rather stupid. Nobody knows everything, you never get someone with limitless experience. Part of systems administration is being able to solve novel problems. Ok well GUIs help in that regard, at least when well designed. They show you your options, and how they flow, what ones exclude and influence others and so on. That can make it much faster to deal with something you are not familiar with. This is important and useful in real IT work.
They also can help prevent errors. For example I can't count the number of times our DNS has been temporarily broken by a student messing up the file. If you do the formatting incorrect, screw up the serial number, etc and suddenly things stop working (we have it in a versioning system so it can be undone easily, of course). In Windows? Not a problem. The GUI keeps you from screwing things up. You can still make a bad entry or whatever, but you can't go and break the entire server.
I'm not saying there's anything wrong with the command line, or that it should go away. However the idea that everything should be CLI based is silly.
I'm a bit curious, could you explain how powershell encourages screen-scraping for those of us who've never had to deal with that beast.
We hope your rules and wisdom choke you / Now we are one in everlasting peace
In my experience, GUIs tend to display less information (probably to not "confuse" users). But from the basic ability to provide useful information, I don't see why one should have an advantage over the other. After all, the information is just text; if that text is shown on the console or in a window with "OK" button doesn't matter. What does matter is whether the text is informative (e.g. "foo.cfg: file not found") or uninformative (e.g. "unable to change configuration" as only error message).
The Tao of math: The numbers you can count are not the real numbers.
That's one thing Microsoft did right with Exchange 2007. They built it entirely around their new powershell CLI and then built a GUI for it. The GUI is limited in compared to what you can do with the CLI, but you can get most things done. The CLI becomes extremely handy for batch jobs and exporting statistics to csv files. I'd say it's really up there with BASH in terms of scripting, data manipulation, and integration (not just Exchange but WMI, SQL, etc.)
They tried to do similar with Windows 2008 and their Core feature, but they still have to load a GUI to present a prompt...
I'm a virgo and on Slashdot. Coincidence? Yes.
Here's something you might want to try: Next time you're on a Windows box, open up a cmd prompt and type "netsh". You might be surprised what you can accomplish from the commandline, at least if you want to mess with the network settings.
I read the internet for the articles.
Because then you'll be stuck at doing simple tasks, and will never be able to do more advanced tasks. Without hiring a team to write an app for you instead of doing it yourself in two minutes, that is.
The time you spend reading man pages is an investment which pays off in the long run. But if you belong to the instant gratification generation, that may not be what you want, no...
learn about how to do it per CLI by looking at the generated shell script
Have you ever seen generated code? You do not want to learn shell scripting from generated code...
In a directory hierarchy, find files with the extension ".ftl" that have been modified since the last SVN revision, and containing the expression "${inventoryItem.qoh}", and for each of these, substitute "${inventoryItem.atp}".
I'd love to see GUI's that can facilitate the kinds of work I do on a constant basis, but since there's no such thing, I've become something of a Unix shell power user over the past couple of decades.
-fb Everything not expressly forbidden is now mandatory.
Ditto, pretty well executed I thought.
Patent litigation: A doctrine of Mutually Assured Destruction... in which everyone seems willing to push the button
Have you ever seen generated code?
Yes
You do not want to learn shell scripting from generated code...
IMO the generation process should be limited to taking the users input and "plugging it in" to a "template" command or short sequence of commands. If a process that is simple in the GUI is complex in the CLI then your system has a design fault.
It's not about teaching the user how to write complex scripts with lots of conditionals (manuals and tutorials are better for that). It's about teaching the users the command line equivalents of their GUI actions and hence creating a bridge between the "discoverability" of a GUI and the power and repeatability of a CLI.
note: i'm known as plugwash most places but i screwd up registering that here somehow in the past and now can't register
Oh there's much more to it than merely the O/S. It's all the applications and third party management tools, too. They all provide GUIs (sometimes only GUIs) as they think it makes their stuff look easy to use. In fact all it does is make it easier to sell to decision makers who don't have the background to distinguish "friendly" from repeatable.
politicians are like babies' nappies: they should both be changed regularly and for the same reasons
And to drive the point of this article home: how long would your post have been if you'd had to describe how to do this through the GUI? Would it have even been possible without screenshots?
Duhh... He does show a keen grasp of the obvious. And for people who use command lines he is preaching to the choir.
On the other hand for the GUI based people, they will miss it entirely. They will talk about add on GUI replay tools that allow one set of mouse clicks to be replayed to many different servers, or configuration management tools that do the work for you. I believe they truly do not understand that someone could get 20 mouse clicks on 40 different servers wrong. "Why would someone ever click the wrong check box?" They also believe that screen shots are valid ways to store configuration information off line.
Only half in jest.
RLH
OTOH, I'd say if there's an important security setting, and it's not set to the secure value by default (or, if that is not possible, gives an error when not set explicitly), that's a design error in the application.
Also, empty configuration files IME are rare nowadays; usually they are pre-filled with (mostly commented-out) example-settings with explanations in comments. Which often allows you to just uncomment the settings you want, instead of writing the complete command by hand.
BTW, comments are another advantage of config files vs. GUIs. Not only because you can state the reason why you put a certain setting right at the setting itself, but also because when you change a setting you can just comment out the previous setting, and therefore easily undo whatever you changed (another option for that is, of course, to make a backup copy of the original config file). I don't see how you can do that with a GUI.
The Tao of math: The numbers you can count are not the real numbers.
But what happens if the system stores those values opaquely, so that you can't ever know what they are, or refer to them as something distinct from the system itself?
The Windows registry.
Apparently, it's fully documented, and much easier to understand, parse, manipulate, backup and restore than those nasty "config files" that need to be "edited manually" using "cryptic commands".
Or so I'm told. ;-)
Your comment on the "rote memorization" aspect of using GUIs I found particularly astute. When I see official documentation that consists of a little other than a series of screenshots, I wonder how it came to be that behaving like a monkey, or more charitably, aspiring to ignorance, became not only widespread, but acceptable.
Probably Debian would have been OK, but I was finding admin of most Linux distros a pain for exactly these reasons. I couldn't find a layer where I could do everything that I needed to do without worrying about one thing stepping on another. No doubt there are ways that I could manage a Linux system without running into different layers of management tools stepping on each other, but it was a struggle.
There were other reasons as well (although there is a lot that I miss about Linux), but I think that this was one of the leading reasons.
(NB: I realize that this is flamebait (I've got karma to burn), but that isn't my intention here.)
Prime numbers are exactly what Alan Greenspan says they are -S. Minsky
I think this is a stronger point than the OP: GUIs do not lead to good documentation. In fact, GUIs pretty much are limited to procedural documentation like the example you gave.
The best they can do as far as actual documentation, where the precise effect of all the widgets is explained, is a screenshot with little quote bubbles pointing to each doodad. That's a ridiculous way to document.
This is as opposed to a command reference which can organize, usually in a pretty sensible fashion, exact descriptions of what each command does.
Moreover, the GUI authors seem to have a penchant to find new names for existing CLI concepts. Even worse, those names are usually inappropriate vagueries quickly cobbled together in an off-the-cuff afterthought, and do not actually tell you where the doodad resides in the menu system. With a CLI, the name of the command or feature set is its location.
Not that even good command references are mandatory by today's pathetic standards. Even the big boys like Cisco have shown major degradation in the quality of their documentation during the last decade.
Someone had to do it.
A pipe to xargs isn't always more efficient.
Consider a script that has to be portable and operate on files with spaces in the name. Portability precludes the -print0 option to find and -0 option to xargs. Nothing is more inefficient than a command that doesn't work correctly, and I've seen plenty of examples of "find ... | xargs ..." that don't work, where an -exec would.
Also consider the situation where you only want to act on a small number out of a large number of files. Then the pipe to xargs will delay execution until you've exhausted the search, while the -exec will perform the job as the files are found. It won't return any quicker, but the load will be spread out, with the first few tasks happening sooner.
Your entire argument is specious--it boils down to thinking that because people don't already know it, it's too hard. With logic like that we'd still be living in the Stone Age.
Much 'easier' than typing it out on the CLI
No. Marginally easier. And that's the bottom line--GUIs make already easy tasks marginally easier, and they make hard tasks (like one of your other repliers suggestion) vastly harder. Unless you never use your computer to do anything complicated, the GUI is a step back.
I have seen generated code. And I've written code generators. And really, the quality of the generated code is completely dependant on whether the developer of the generation tool was merely doing whatever was required to get working generated code, or to provide a useful tool to users to learn and expand upon.
Too often I see devs handed a task and do the bare minimum to get that one specific task completed. Instead of looking for a bigger picture of the task and seeing if they can get more out of it with little to no extra effort. Because, really, getting your output to be readable is not nearly as complex as creating the UI for it anyway. Took me on the order of hours to tweak my output to look right, and not even 50% of that time again to tweak it in the way that feedback recommended (some of which I disagreed with and responded as such, the rest I agreed with or was ambivalent upon and thus changed). The rest of the project took months of effort. Skimping out on readable output is a false savings here.
It's not hard to do. A good template tool (in perl, I use Template Toolkit), and 90% of the problem of readable output is solved.
The only times I don't care about readable output have been generating xml and xhtml. Even when I generate C++ and Java code that is going directly from there to the compiler and not read by any user, I try to get the output reasonably readable - which makes it much easier to deal with compile errors when they point to a line number that has only a single statement on it, or when I bring the resultant app up in a debugger and want to step through the code for one reason or another. The time saved in debugging compile or runtime errors alone can pay for the effort in readable output over and over again.
Providing a great GUI for complex routers or Linux admin is hard. Of course there has to be a CLI, that's how pros get the job done. But a great GUI is one that teaches a new user to eventually graduate to using CLI.
Just about everyone reading this is heavily biased one way or another, and there is too much presumption that a CLI is this or a GUI is that.
Why can't we break this down into what makes any type of interface good or bad, and keep open to the possibility of new types of interfaces or better ways of implementing existing ones?
If we can bitch and moan about CLI vs. GUI with little choice in the matter I think the floor's open to made up interfaces too. These are qualities I think any computer interface should have.
Learning curve no steeper than the underlying concepts. Probably even lower.
Consistent, and predictable.
Expressive, and concise.
Integrity. Um.. as in, the state of the machine vs. what's conveyed to the user. Accurate?
Available over a network.
Can be automated.
Online documentation. Of the interface. If you have trouble describing the concepts in your native language, maybe it sucks.
Efficient, in the sense of labor involved, but in the sense of learning too, like my first rule.
That's a start anyway. I don't see why any kind of interface can't shoot for those. For sure if you're going to deliver more than one kind if interface they should relate to each other as much as possible. A CLI is dead simple to turn into script, but a GUI could also be. A CLI should map so closely to a corresponding GUI that it effectively IS a script of the GUI. A GUI should convey state information just by looking at it. Duh. If it doesn't HAVE to be an either/or situation, why make it into one?
What would be REALLY nice for you all router manufacturers who are using Linux underneath the hood is to give shell access so that we could gain full access to iptables, vpn and routing. Just about every one of these Linux-based routers has all that power locked up in your crappy web-based configuration tools that render them all but brain dead. Yeah, I know, there's DD-WRT and its various iterations, but these only work on a subset of Linux-based routers.
The world's burning. Moped Jesus spotted on I50. Details at 11.
"If your GUI dosn't offer the same advantages than a console/terminal text interface, then your GUI is lacking some features and is a GUI for some but not all your needs, very common in the nix world btw"
Now, please, tell me how well a GUI-oriented environment copes with:
* Repeatability (I want exactly the same you did yesterday on server A, now on server B)
* Auditory (what did change in this server from yesterday, who did it?)
* Automation (remember what you did yesterday on server A? I want you to do it again on server B; but do it tonight at 2AM -no, no extra hours payment allowed)
* Conformance (now that we know how exactly it has to be done from our working on the test environment, let's do it -without mistakes, in our 100 production servers)
* Orchestration (let's do changes a, b and c on servers A, B and C as fast as possible, without mistakes, in proper order and each step only after being sure the previous one is properly working -oh, and let's do it at 2AM -why do you ask it again? No, no extra hours payment allowed)
For I know all of them are virtually trivial on text-based CLI-oriented systems.
It wouldn't have been so bad if Microsoft had just supplied a generalized configuration parser for application developers to use. Then it could be applied to files, streams, digitally signed blobs, whatever.
But no, they had to build another way to lock you in, didn't they? So you don't get the security controls or network transparency of the file system. You're not reusing the file system, so you have added another source of complexity and another attack surface for security. You don't get composability or scope control where one subsystem can feed live configuration data to another.
And if the Registry breaks, you're kind of hooped. Sure, there's regedit, but it's off to the side, not part of the main paradigm. Mostly it serves to remind you of what you're missing. It's far from common practice to track changes to the Registry in order to monitor how an application has been configured. And that's because the application has not necessarily used the Registry. So tracking it is in general neither necessary nor sufficient.
Ooh. Don't get me going.
Parity: What to do when the weekend comes.
If you were to read a how-to on a blog about configuring a router using a GUI, it would take a few pages. If it were about configuring a router using a CLI, it would fit in one page. Bottom line: in today's world where a forgotten command can be remembered quickly using our friend Google, I much prefer CLI because it makes me read less, and do more.
iTx Technologies: Open source development in Montreal
> * It requires a sysadmin with a clue
> * You need to not be a mouth-breather to configure it
Still wonder why you're not taken seriously, eh?
I like Samba. It could use less advocates like you.
There are a number of features in powershell that unix CLI environments would do well to adopt. It's okay to admit ignorance, but please stop trying to cover for it with pontification.
The last Microsoft product I bought was Windows 98, so I have mercifully missed the whole disaster since then. All my clients are just now starting to switch from XP to Windows 7, because I advised against Vista.
I was like you. I advised people to avoid Vista without having tried it too. Then I did try it and found that most of the bad things people said about it were just outright lies. There were some problems, but it was nowhere near as bad as everyone claimed.
And in all these years of supporting dozens of computers I have never heard of PowerShell until this article.
I'm not surprised since your clients were taking your advice and you hadn't heard of it. It stands to reason that they wouldn't be using it. Powershell has been around for 4 or 5 years now, and it does appear in everyone's Windows Update list as an optional download. No offense, but I'm not sure how you support Windows users with only knowledge of Windows 98.
Too bad they did not build on Xenix, and save everyone much grief. Imagine where Apple could have been in the 90s, had they switched to Unix a decade earlier.
The problem with Windows isn't with the core technology. The NT kernel is quite solid. The problem is what they did on top of that. ActiveX in a browser was just asking for trouble. Leaving ports open and services running by default might make it easy for plebs to run programs and network services without having to configure them, but it is suicide for security. Even if it had Xenix underneath, they still would have been up the creek with idiotic decisions like that.
For sure if you're going to deliver more than one kind if interface they should relate to each other as much as possible.
Under this expanded mandate, let's also compare the programmatic interface to the system with the command and graphical interfaces. I've always been bothered that there isn't a tight relationship between the standard Unix command set and their programmatic equivalents. It's pretty accidental, and that's a shame. As long as the coupling is not rigorous, that means two learning curves as well as two compatibility surfaces to maintain.
I used to ponder this a lot, so it was very instructive to work with the Symbolics Lisp Machine for a few years. Here we had an environment which was Lisp from the microcode upward. It was a completely fresh start, a chance to do it right. The operating system was very open. And with Lisp being an interpreted language, you'd think it would be dead easy to provide a rich CLI that gave direct access to both the system and the GUI.
Well, no, that's not how it worked out. Part of that is due to our natural fondness for line breaks as command delimiters. Lisp wants things to be delimited by parentheses. But that's not an insurmountable problem. Unfortunately, the Symbolics developers thought it was, and they instead went off and built a CLI that was only vaguely coupled with the corresponding system methods. It was heartbreaking to see such a basic advantage thrown away.
To make matters worse, when the CLI ended up throwing an exception (which was not all that uncommon in such an experimental environment) what you saw on the stack bore little resemblance to the documented system methods. See, most of those were not really methods at all but wrapper macros of one kind or another. So, you'd execute a shell command, which would invoke one of these macros, which would push some undocumented methods on the stack. And since the CLI didn't relate to the system documentation, you'd have to guess where to go to find the documented methods.
It could have been the best. Instead it was kind of the worst. Well, I guess it beat looking at IBM core dumps.
Parity: What to do when the weekend comes.
I've never been in a decision-making position for choosing a server for a company but over the last ~seven or eight years I've come to conclusion (I'm some will correct me if I'm wrong) that there aren't really meetings in which a group managers balance the pluses and minuses of Linux/Samba verses whichever Windows server. That look at entire apparent cost-of-ownership, in particular the support contract.
In other words the main draw is the service contract: if any hardware fails on any server an 800 number is called and less than 24 hours later either the replacement part is delivered or a tech of some sort is there ready to install the part that needs replacing.
I don't think most at least large companies really care about brands so much. I mean I don't think they're loyal to Windows in so much as the Dells and HPs of the world will win the bid for phone support/hardware replacement for three or five or whatever number of years at a time. And that Dell contract will extend to an MS support contract along with server/desktop licensing etc. Companies pay huge amounts of money for things like always having someone that can be called and a replacement part in under 24 hours.
So, am I way off?
"UNIX is very simple, it just needs a genius to understand its simplicity." -Dennis Ritchie
GUIs can make unknown operations significantly easier
IMO, this is the biggest advantage that GUIs have over CLI: they allow you to see all of the legal choices at once, and as you make a change in one field you can see which other fields are now made illegal. Good "help" in a CLI can help, but it's much more trial and error. Esp if the help isn't good, and you combine illegal choices.
--
$tar -xvf
You forgot:
Seems to depend on OpenLDAP, which is in itself generally too unstable for production use once you pass a few hundred users.
In my experience perl is on most unix machines, and works quite well for cross-platform tasks.
:).
Can't depend on Java or GNU tools to be present everywhere, but so far I've found perl on OSX, Solaris, OpenSolaris, AIX, most Linux distros and FreeBSD.
So if I ever had to write a cross platform unix/linux virus I'd write it in perl
I'm a little puzzled why your clients pay you for advice on Windows when you don't use or pay attention to it. PowerShell has close to 4 million hits with a Google search and was much discussed on slashdot.
NT derived Windows have some amazingly powerful command line tools that in some cases are far better than *nix tools. Check out Ed Skoudis' many articles and podcasts on command line kung fu.
Too bad they did not build on Xenix, and save everyone much grief.
As someone else noted, the NT kernel is really pretty good. It was buggy third party drivers and bad non-kernel decisions that created the vast majority of the problems. Any OS that allows a wide range of hardware is going to be vulnerable to buggy drivers.
Imagine where Apple could have been in the 90s, had they switched to Unix a decade earlier.
They did.
http://en.wikipedia.org/wiki/A/UX
I've seen this in a few places, why is pf preferred over iptables? What can it do that iptables cannot? Or is it performance related? Security?
Ridiculous. I am all for Unix tools and prefer the Unix way for most server related tasks and apps, but Samba4 doesn't even come close to being able to dealing with an ADSI install. Even doing something basic like rolling out GPOs is either a giant pain in the ass, requires Windows-based tools still, or is impossible. As a generic SMB server, Samba is excellent. As a domain controller/active directory store, it has a LONG way to go before it's even close to viable as a replacement for AD.
GUIs usually are a management requirement. The common misconception is that sysadmin GUIs make you more productive. Well, they don't. On the contrary, they slow you down, cause repetitive and boring activities where the human factor thrives (E.g. copy paste from spreadsheet.) GUIs look good on presentations but are crap to operate.
But it's not only the god forsaken Windows platform that has them. Ever tried configuring network interfaces and the DHCP server on OpenSolaris? Ever tried getting a readable manual on how to do either by editing files or through command line? That for me was the practical reason for discarding OpenSolaris and continuing with FreeBSD.
In an ideal world, configuration files adhere to a specific syntax. Libraries are available and convenience tools and utilities (CLI and GUI) should be based on them and are equally effective.
Cheerfully ignore comments stating that scripts for changing configuration files can screw up production. Hobbyists stating such manure apparently don't know you should run unit and integration tests before deploying any change whatsoever in a production environment. Nowadays any half professional organisation can afford multiple test environments to minimise production failures caused by untested software.
I hadn't the slightest objection to his spending his time planning massacres for the bourgeoisie... (P.G. Wodehouse)
You are not qualified to advise people on using Windows XP, Vista or 7 if your knowledge stops at Windows 98.
If I said Linux was a shitty desktop OS, because when I used it in 1998 the sound didn't work properly, everyone would just laugh.
To have a right to do a thing is not at all the same as to be right in doing it
This would sound a bit convincing if you actually mentioned a feature by name rather than spouting something that sounds like vague marketing propaganda.
A Pirate and a Puritan look the same on a balance sheet.
YaST over SSH in not CLI, it's TUI. The important difference is CLI is scriptable, TUI has the lack of scriptability of a GUI, but the bandwidth characteristics of CLI.
I think it's a nice example of how something running in a text-only mode is not necessarily a sufficient improvement over GUI.
XML is like violence. If it doesn't solve the problem, use more.
Wow, I can't believe that this is just accepted.
With the advances in GUI design and beyond GUI design technology, a CLI should be obsolete, even if it is not obsolete in practice on the specific examples.
There is no reason a written script should be necessary, when an object constructed visual script could also be generated that is just as specific and functional. Again, just because the tools and technology are not common does not mean it is the standard and will always be a truth.
There was a time that writing software required 'writing code' as well, and today we have technologies that let graphic designers put together robust applications without writing a single line of code. (MS Blend for a simple example of XAML based GUI development.)
By nature Unix based OS models are CLI dependent(textual pipes and generic I/O constructs); however, this is not true of all OS models(NT is an object based OS, where a CLI is counter intuitive which makes PowerShell a brilliant CLI model that came years after the OS, and uses the object nature of the OS design).
Even with some imagination this isn't a 'truth' in a UNIX OS model either. There is no reason that all constructs have to derive or remain at a CLI level with a GUI strapping onto the CLI. Replace the CLI constructs with GUI based interactions and instead of textual pipes, object and graphical piping could be the model that replaces the CLI nature of UNIX.
This line of thinking is a failure of imagination and factually incorrect when viewed from an object based OS design like NT where the CLI(PowerShell) was an achievement to harness objects at a regressed CLI level.