Take This GUI and Shove It 617
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.'"
Bad GUI and no CLI: way too common (Score:5, Informative)
Here is a Link to the print version of the article [infoworld.com] (that convenientily fits on 1 page instead of 3).
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.
A bad GUI with no CLI is the worst of both worlds, the author of the article got that right. The 80/20 rule applies: 80% of the work is common to everyone, and should be offered with a GUI. And the 20% that is custom to each sysadmin, well use the CLI.
--
dead simple alternative [fairsoftware.net] to incorporating for web startups
Re:Bad GUI and no CLI: way too common (Score:5, Insightful)
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.
Re: (Score:3, Informative)
Exchange Server 2007 (and I assume 2010) does this for many of its GUI operations, gives you the powershell after you've run it.
Re:Bad GUI and no CLI: way too common (Score:4, Informative)
Just about every Microsoft tool newer than 2007 does this. Virtual machine manager, SQL Server has done it for ages, I think almost all the system center tools do, etc.
It's a huge improvement.
Re: (Score:3, Informative)
Re: (Score:3, Interesting)
Why would you even want Server 2008 to run without a GUI? The windows command line tools are dodgy and it only takes up like 64MB of your 16GB server memory.
Re:Bad GUI and no CLI: way too common (Score:5, Insightful)
> * 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.
Re:Bad GUI and no CLI: way too common (Score:4, Informative)
You forgot:
= Still alpha code.
= Cannot handle multiple group membership from a Linux file system, such as NFSv4 (http://www.pubbs.net/201004/samba/41361-samba-viewing-if-not-editing-nfsv4-acls-from-samba-shares.html).
Re: (Score:3, Insightful)
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.
Re:Bad GUI and no CLI: way too common (Score:5, Informative)
I liked SMIT.
Re: (Score:3, Insightful)
Re: (Score:3, Interesting)
It's been years since I administered an AIX machine but my recollection is that the CLI command strings it came up with were generally amusingly-specific unique-to-AIX commands with very long names like resizepartitionandinstallbootblock or something like that. They were generally specialty scripts built t
Re: (Score:3)
Why are you and the GP talking about SMIT in the past tense? ("did this," "was") It still exists and it still does this.
Re: (Score:3, Informative)
Aruba's web-based GUI does this. You stack up all of your changes per-page, and you can click on an option at the bottom that shows you the CLI changes that it will make (since it's going to run just those lines when you apply it anyway). It shows you when something is simple and can be done quickly from the CLI, and also when what takes three clicks actually takes five or six somewhat complex lines.
Re: (Score:3)
That would be one option. Another would be to be able to drive the GUI from a script (test systems such as Silk and Selenium already do this). Provided standard options were accessed in a standard way, there is nothing to stop you from driving things from this direction. Alternatively, have a configuration server that applications installed plug-ins for. The configuration server can then abstract out the nuances. You then feed it a script in the server's language and it takes care of the configuration detai
Re: (Score:3, Informative)
"What would be nice is if the GUI could automatically create a shell script doing the change"
AIX's SMIT, and it's... how old? merely 20 years now?
Re: (Score:3, Informative)
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.
Cisco's GUI stuff doesn't really generate any scripts, but the commands it creates are the same things you'd type into a CLI. And the resulting configuration is just as human-readable (barring any weird naming conventions) as one built using the CLI. I've actually learned an awful lot about the Cisco CLI by using their GUI.
We've just started working with Aruba hardware. Installed a mobility controller last week. They've got a GUI that does something similar. It's all a pretty web-based front-end, but i
Re:Bad GUI and no CLI: way too common (Score:5, Insightful)
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.
Re: (Score:3, Insightful)
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 wit
Re:Bad GUI and no CLI: way too common (Score:4, Insightful)
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.
Re: (Score:3, Insightful)
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?
Re:Bad GUI and no CLI: way too common (Score:4, Interesting)
Could be configuraion syntax. Simple, readable, concise, possible to understand even in very complicated scripts without looking at the manual. I'm using iptables routinely, but I liked pf for its simplicity.
Re: (Score:3, Informative)
My root has the ability to download and upload the config as xml. I downloaded it, noticed that it's possible to change the admin's username, and did, thinking that it's an extra step towards defence in depth. Of course, the router didn't like it - it accepted the config but now neither the old username nor the new one work. If I ever want to change the config again I'll have to reset to factory defaults first.
Re: (Score:3, Insightful)
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.
Re: (Score:3, Informative)
Cool, now move only the files that end in mp3, do not contain a number in the name and are between 10 and 60 days old. I bet the CLI starts looking might fast then.
Re: (Score:3, Insightful)
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 de
Re: (Score:3, Insightful)
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
Re: (Score:3, Insightful)
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.
Re: (Score:3, Interesting)
1) Your argument against CLI is a moronic volume mounting system designed explicitly to only be used with a GUI. Really, the whole C:, D:, E: thing was fucking moronic. The Unix scheme of mounting seamlessly as a folder under /, in a way which renders the underlying volumes invisible is far saner (which is, of course, an entirely separate debate from the merits of CLI vs. GUI, but a personal pet peeve with Windows).
2) Tab completion. I don't think I've ever typed more than 5 letters of a filename, of any
Re: (Score:3, Informative)
I couldn't agree more which is why it's really cool that the Exchange GUI tools will show you the exact PowerShell commands they are running if you want to learn how to use the CLI (and in fact that are still things that can only be done in the CLI, though the list is greatly reduced in EX 2010 vs 2007).
Re: (Score:3, Interesting)
I couldn't agree more which is why it's really cool that the Exchange GUI tools will show you the exact PowerShell commands they are running if you want to learn how to use the CLI (and in fact that are still things that can only be done in the CLI, though the list is greatly reduced in EX 2010 vs 2007).
Crap. I was hoping they would've encouraged more CLI and less GUI... (using Exch2k7 here - haven't had time to dink with 2010 yet). I'm guessing the typical MCSE types (comprising the majority, not the whole) have decided that command-line stuff must be too hard to learn.
Re:Bad GUI and no CLI: way too common (Score:5, Insightful)
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?
Re:Bad GUI and no CLI: way too common (Score:4, Insightful)
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.
Re: (Score:3, Insightful)
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.
Re: (Score:3, Insightful)
Re:Bad GUI and no CLI: way too common (Score:4, Informative)
Screen-scraping? Really?
Re: (Score:3, Insightful)
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 optiona
Re: (Score:3, Insightful)
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
Re:Refusing to feed the beast is not mindless (Score:4, Insightful)
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.
Re: (Score:3, Insightful)
This would sound a bit convincing if you actually mentioned a feature by name rather than spouting something that sounds like vague marketing propaganda.
Re: (Score:3, Informative)
Another concept used by PowerShell is that of a pipeline. Like Unix pipelines, PowerShell pipelines are used to compose complex commands, allowing the output of one command to be passed as input to another. A pipeline is set up by piping the output of one command (or pipeline) to another command, using the | operator. But, unlike its Unix counterpart, the PowerShell pipeline is an object pipeline; that is, the data passed between cmdlets are fully typed objects
GUIs make documentation hard (Score:5, Interesting)
With a CLI or a script that's easy: it comes down to "log in as user X, change to directory Y, run script Z with arguments A B and C - the output should look like D". Try that when all you have is a GLUI (like a GUI, but you get stuck): open this window, select that option, drag a slider, check these boxes, click Yes, three times. The output might look a little like this blurry screen shot and the only record of a successful execution is a window that disappears as soon as the application ends.
I suppose the Linux community should be grateful that windows made the fundemental systems design error of making everything graphic. Without that basic failure, Linux might never have even got the toe-hold it has now.
Re:GUIs make documentation hard (Score:5, Insightful)
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.
Re: (Score:3, Insightful)
Re: (Score:3, Funny)
That's true, but has absolutely nothing to do with what he said. GUIs do not usually display graphs. They usually display a little message box saying "An error occurred. Please try again. If the problem persists, contact your system administrator."
Better test! (Score:5, Insightful)
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.
Re:Better test! (Score:4, Insightful)
Re:Better test! (Score:5, Informative)
Yes, we do. In many case it's called a chroot jail which acts as a sandbox.
In other cases, a VM that can be rolled back is the way to go.
There are two words describing those who run untested changes directly on production systems: Former employees.
Re: (Score:3, Interesting)
Actually they had no clue what a 'good server' was, so when they left it up to me they were functional and up to date systems. Though most of our windows servers were from HP's server line.
Others not so much, like when they decided web hosting should move in house and gave me a zero dollar budget. So I cannibalized a bunch of antique desktops and made a new 'linux apache web server'.
Funny enough I'd gotten a 5k raise every year (much needed though as the pay started fairly low for an network admin). Though
Re:Better test! (Score:5, Insightful)
Re:Better test! (Score:5, Funny)
Ah, but with a script you have a record of what was done.
True, unless your script was:
Re:Better test! (Score:4, Interesting)
Well, one little mistake pushing a windows domain policy via GUI, and the same.
This is one of the weakest points in the article, IMO, though. It's quite possible (even if MS MMC is a kludgy example) to GUIfy multi-system administration.
There will always be a place for both GUI and CLI -- status screens, for example, generally demand a GUI (and yes, ANSI menu systems are a GUI.)
Re: (Score:3, Interesting)
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.
It is also easier to fix scripted errors because the error is identical in all places. I often find myself using sed to make complicated changes to config files and keeping backups or putting the changed config into a temporary file to get diffs of the results. In the odd case that something gets messed up in production, then it is usually another sed command or two to fix it.
With a GUI it is harder to verify that you are making the desired changes beforehand, and if you do mess it up royally, then you are
Re: (Score:3, Insightful)
Scripts can be debugged, working out which pictures were pointed at is a bit more tricky.
Communicating with computers can be compared to communicating with people. You can get somewhere by pointing at things but you get better results faster if you can use words as well.
One small problem... (Score:5, Insightful)
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.
Re: (Score:2)
You meant Windows admins, right?
Re:One small problem... (Score:5, Interesting)
Its cheap, its easy and its stable. I'm sure if you look through all of the businesses running servers, very few of them are ran by real "admins" but rather by the employee who "knows about computers"
Well there's another side to that (Score:5, Insightful)
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.
Re:Well there's another side to that (Score:5, Insightful)
"I find it rather disturbing the UNIX ideal that sysadmins should be programmers."
That should be the case, but it isn't firstly because becoming a good sysadmin is a full time activity as it is being a good programmer and secondly because of subtle character differences between the people that choose one role or 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."
Yes, there is, and very wrong. Maturity of current IT systems is still far away to what's needed to be able to work in aisles. A programmer doesn't need to be a top notch sysadmin nor the other way around, but they both need to have very clear ideas about the other's trade because is needed both to understand where your program is going to be run and how and what would make proper practices to acomodate the programs within a wider and partially peculiar local environment (and in order to recognize properly engineered programs from lame intents).
"Not everyone should have to learn that skill, and you could well be excluding people you want by requiring it."
And, in fact, not everyone needs to learn that skill, it's only sysadmins that need it. And take for granted you are not excluding interesting people to fill a sysadmin role if they don't have at least clear foundations on programming.
"Also there's the simple matter that GUIs work better for unfamiliar situations."
Quite true (but proper man pages with examples and tutorials work almost as well).
"Part of systems administration is being able to solve novel problems. Ok well GUIs help in that regard, at least when well designed. "
But don't forget a *very* critical point: a new thing is only novelty the first time you do it. Do not let a bit of easiness for your first time getting in your way for the subsequent 10.000 times you will do it again from then on.
And that's exactly why GUIs sell so good. When you are "buying" something new (it might mean literarilly exchanging money, but it means commiting yourself to the effort that will require work with new thingie) it usually will be to do new things, which is the kind of situation when GUIs (and "wizards", for that matter) will help, so the GUI by itself will be a very valuable agent to sell the app/services. By the time you understand that the shiny GUI gets in the middle you have invested too much in the app (money, time and effort) to get away from it. Microsoft, for instance, has learnt that leson very, very well.
"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."
That's not an argument, it only seems to. While "manual handling" is prone to syntax failures, GUIs are prone to knowledge failures which are, by the way, much, much more dificult to debug. For each time you had a student making a severe syntax error on a DNS zone file, I can show you a self-called sysadmin making horrible design choices that led to situations dificult to repair and problems dificult to debug because the GUI allowed for an action on Windows environments (which was not a failure of the GUI itself, because the action was correct under the proper circumnstances, but because the GUI allowed for someone without enough knowledge on the consecuences of their acts to do "something" resulting in an "OK" message: a case of "garbage in, garbage out").
So it's a stalemate on this.
"In Windows? Not a problem"
Now that you mention the text config files vs. GUIs on a multiple admins (some of them students) environment, here comes a hugh problem with the vast majority of GUIs:
You get at work early in the morning and something is not working properly. You summon your minions and tell them "something is broken; what have you messed up since yesterday?"
On a text files-based environment the answer is easy and you already advanced it: "we have it in a versioning system so
Re: (Score:3, Insightful)
Never mind the things that the GUI just can't do, because the GUI is limited by the knowledge of the person who wrote it. Try entering an rdata_44 record in the DNS thro
Re: (Score:3, Insightful)
I'd presume this comes about from the fact that [administration] software used to be very expensive so it was normally cheaper to hire a sysadmin/programmer than to hire a sysadmin and seperate software. The fact that most sysadmins used to be at least minimally programmers (ie, they could write a
Re: (Score:3, Interesting)
All I have to say is: Amen! (in a nonreligious sort of way)
I'm a not very good programmer who is a good system admin. I've been fighting the general apathy to anyone who can't read the source for the linux kernel in the linux world for going on a decade now! I'm always being told 'write it yourself' when I bump into a wall in administering linux systems that would be a simple button press in Windows... I don't want to reinvent the wheel! I'd frankly suck at it! That A) doesn't mean I'm a bad admin and B) Is
Re: (Score:3, Informative)
"I find it rather disturbing the UNIX ideal that sysadmins should be programmers."
Funny, nobody finds it disturbing when I interview for a job. Usually they just say holy crap
you are a experienced and accomplished programmer as well as a crack administrator, hired.
Re: (Score:3, Interesting)
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.
Not only have I spent over 10 years as a professional *nix system administrator, I currently work training professional system administrators. I don't know *anyone* who thinks that a system administrator should be a programmer. That being said, shell scripting is a tool of the skilled system administrator. Writing simple scripts is nothing like programming. While shell scripts can be quite complex, most that a system administrator would write are very simple. Really just a series of commands.
I know more than a few programmers that are abysmal at system administration...
And how! The va
Re: (Score:3, Insightful)
If you type a question mark in the IOS CLI, it will show you all of your possible options from that point. Tab completion is another way to accomplish that, some CLIs use that.
In Unix, you have the tab completion, man and apropos to help you out.
Shell languages are designed with an emphasis on very simple "programming" tasks such that a sysadmin can easily use it for simple string substitutions and such while it remains a turing complete language (meaning anything that can be expressed to a computer can be
GUI interface can sell a product to management (Score:5, Interesting)
Without a GUI it will be hard to sell, but automation is next to impossible with GUIs, so they are expensive to use in the long run because you have to pay for more Users.
/etc/resolv.conf (Score:3, Interesting)
Agreed. For instance, I've been trying to figure out how to add a simple "search" entry into resolv.conf in Fedora .. it keeps overwriting it on boot no matter what level scripts I modify (e.g. going up to DHCP config, etc.) - because some genius came up with a new admin tool and thought that something as basic as resolv.conf doesn't need to be followed.
Re:/etc/resolv.conf (Score:5, Informative)
Usually there will be resolv.conf.head and resolv.conf.tail files somewhere which get stuck at the beginning and end of the generated resolv.conf.
That way you get a semi-dynamic and semi-static config.
Re:/etc/resolv.conf (Score:5, Informative)
/etc/init.d/NetworkManager stop /etc/sysconfig/network /etc/sysconfig/network-scripts/eth0
chkconfig NetworkManager off
chkconfig network on
vi
vi
At least they named it NetworkManager, so experienced admins could recognize it as a culprit. Anything named in CamelCase is almost invariably written by new school programmers who don't grok the Unix toolbox concept and write applications instead of tools, and the bloated drivel is usually best avoided.
Re:/etc/resolv.conf (Score:5, Insightful)
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?
Re: (Score:3, Interesting)
More and more... (Score:5, Insightful)
So with the increasing use of servers among non-admins, it only makes sense for a growth in GUI-based solutions.
Re:More and more... (Score:5, Insightful)
The trouble with Linux, and I'm speaking as someone who's used YaST in precisely this context, is that you have to make a choice - do you let the GUI manage it or do you CLI it? If you try to do both, there will be inconsistencies because the grammar of the config files is too ambiguous; consequently, the GUI config file parser will probably just overwrite whatever manual changes it thinks is "invalid", whether it really is or not. If you let the GUI manage it, you better hope the GUI has the flexibility necessary to meet your needs. If, for example, YaST doesn't understand named Apache virtual hosts, well, good luck figuring out where it's hiding all of the various config files that it was sensibly spreading out in multiple locations for you, and don't you dare use YaST to manage Apache again or it'll delete your Apache-legal but YaST-"invalid" directive.
The only solution I really see is for manual config file support with optional XML (or some other machine-friendly but still human-readable format) linkages. For example, if you want to hand-edit your resolv.conf, that's fine, but if the GUI is going to take over, it'll toss a directive on line 1 that says "#import resolv.conf.xml" and immediately overrides (but does not overwrite) everything following that. Then, if you still want to use the GUI but need to hand-edit something, you can edit the XML file using the appropriate syntax and know that your change will be reflected on the GUI.
That's my take. Your mileage, of course, may vary.
Re: (Score:3, Insightful)
"Realistically, if you're a company with less than a 100 employees [...] it just won't matter to the admin if they can script, say, creating a mailbox for 100 new users instead of just one."
Well... it won't matter till the day your single server dies and you learn that, being a little drop in the sea, you don't have a "gold support contract" and it takes you one week to get a new spec'ed server (if only I weren't such a cheap ass and I'd buy two...). And when you turn on the new server you learn that you d
Re: (Score:3)
Don't you think you are splitting hairs just a little too fine?
http://www.youtube.com/watch?v=fVU1FOLnu_E [youtube.com]
Config files. (Score:3, Insightful)
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.
Re:Config files. (Score:4, Informative)
Really? Ever heard of editing /etc/profile and changing the PATH statement there? No, there's no GUI tool- but under Windows it's not wholly clear like you make it out to be where it is. Yeah you can change it- but then so can I under Linux in as much of an easy way as you can under Windows- it's just different and if you're unfamiliar with one or the other, you're not going to be doing it on EITHER.
Re: (Score:3, Interesting)
Yeah, instead of flat text conf files, why don't we put a whole bunch of config in some obscure place in the registry somewhere...
i entirely fail to see the point as to why you would want a gui to do something that is integral to the cli.
Webgui? Just use cUrl (Score:5, Interesting)
I have a cheap router with only a web gui. I wrote a two line bash script that simply POSTs the right requests to URL.
Simply put, HTTP interfaces, especially if they implement the right response codes, are actually very nice to script.
Yes (Score:3, Insightful)
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.
Exchange 2007 and Powershell (Score:4, Insightful)
They tried to do similar with Windows 2008 and their Core [petri.co.il] feature, but they still have to load a GUI to present a prompt...
Re:Exchange 2007 and Powershell (Score:4, Informative)
There has been a steady transition to PowerShell for all Microsoft server products, precisely so as to enable CLI scripting with full feature coverage, similar to what has been enjoyed on Unix for a long time. It had started with Exchange 2007, but the most recent addition (to the best of my knowledge) is SharePoint 2010 [microsoft.com].
Why I moved to FreeBSD (Score:4, Insightful)
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.)
Comment removed (Score:3, Interesting)
Re: (Score:3, Insightful)
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.
GUIs are a management requirement (Score:5, Insightful)
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.
Grandpa, Really? (Score:3, Insightful)
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.
Re: (Score:3, Insightful)
Sadly you don't even understand how silly your response is.
NT and piping are opposites in how the OS is designed. NT deals with objects and object passing and referencing, not generic I/o and piping.
Nt is specifically not designed like unix, which was my point and what you do not understand.
An OS that deals with an object model instead of generic I/o has no need for textual passing or piping.
More slashdot peeps truly should take a minute to learn why makes NT different and unique from standard unix OS mod
Re:ITT: "Get off my lawn" (Score:5, Interesting)
Probably because it's also about the ease of troubleshooting issues.
How do you troubleshoot something with a GUI after you've misconfigured?
How do you troubleshoot a programming error (bug) in the GUI -> device communication?
How do you scale to tens, hundreds, or thousands of devices with a GUI?
CLI makes all this easier and more manageable.
Re: (Score:3, Insightful)
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
Re:ITT: "Get off my lawn" (Score:4, Interesting)
I don't think you really understand systems administration. 'Users,' or in this case admins, don't typically do stuff once. Furthermore, they need to know what he did and how to do it again (i.e. new server or whatever) or just remember what he did.
One-off stuff isn't common and is a sign of poor administration (i.e. tracking changes and following processes).
What I'm trying to get at is that admins shouldn't do anything without reading the manual. As a Windows/Linux admin, I tend to find Linux easier to properly administer because I either already know how to perform an operation or I have to read the manual (manpage) and learn a decent amount about the operation (i.e. more than click here/use this flag).
Don't get me wrong, GUIs can make unknown operations significantly easier, but they often lead to poor process management. To document processes, screenshots are typically needed. They can be done well, but I find that GUI documentation (created by admins, not vendor docs) tend to be of very low quality. They are also vulnerable to 'upgrades' where vendors change the interface design. CLI programs typically have more stable interfaces, but maybe that's just because they have been around longer...
Re: (Score:3, Informative)
'admins don't typically do stuff once' WTF world do you live in...? I administered a 500 user network a bit over a year ago and very few things were repeated. I set up servers once, and then unless I needed to change something I didn't need to reconfigure them. Now some things like new user accounts is common and repeatable... But those take 2 or 3 minutes and it's done, unless you really cycle massive amounts of employees this should never be more than a half hours work... And a GUI is easily adept at simp
Re: (Score:3, Insightful)
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.
Re:And the whole GUI overhead (Score:5, Informative)
it's called a "core" install in Server 2008 and up, and if you do that, there is no going back, you can't ever add the GUI back.
What this means is you can run a small subset of MS services that don't need GUI interaction. With R2 that subset grew somwhat as they added the ability to install .Net too, which mean't you could run IIS in a useful manner (arguably the strongest reason to want to do this in the first place).
Still it's a one way trip and you better be damn sure what services need to run on that box for the lifetime of that box or you're looking at a reinstall. Most windows admins will still tell you the risk isn't worth it.
Simple things like network configuration without a GUI in windows is tedious, and, at least last time i looked, you lost the ability to trunk network poers because the NIC manufactuers all assumed you had a GUI to configure your NICs
Re: (Score:3, Informative)
it's called a "core" install in Server 2008 and up, and if you do that, there is no going back, you can't ever add the GUI back.
Win2008 Core still has a GUI. It's just that it's a GUI that only has a single graphical terminal window open by default, but nonetheless there's a window manager and all the other stuff. And you can open more terminals, and run GUI apps which open their own windows as well (if I remember correctly, it does have Notepad out of the box which can be used that way).
That said, resources consumed by such a thing are so tiny that they won't be noticed even on a mid-range modern desktop, much less an actual server
Re: (Score:3, Insightful)
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
Re: (Score:3, Insightful)
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 composabil
Re: (Score:3, Insightful)
"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 a
Re: (Score:3, Funny)
How, pray tell, do you export that to a CSV file?
Print Screen and OCR, then write a perl script.
Re: (Score:3, Interesting)
Only that you went back to mention Scripting under CLI. True, every OS I seen that implements it allows for it to be scripted, but this is not necessarily true.
An application can be written with dual interfaces, GUI + CLI (at least in windows) and [arguably] bad design can lead the CLI to require a user to confirm actions without allowing the confirmation to be scripted.
On a similar line, I have seen GUI programs that have designed CLI equivalents for every menu and button with confirmation bypass param