How to encourage Windows administrators to pick up scripting? [closed]

Question

When I worked as an administrator in my first job, I was frustrated that our administration processes with Windows servers were a series of point-and-clicks; we could never match the level of efficiency with the Unix servers which had a group of shell scripts to automate a lot of the work. I soon read about WSH and ADSI and wasted no time learning just how much automation I was able to achieve with scripting.

There was a huge problem though - almost none of my Windows colleagues were really interested in learning scripting. They seemed happy with the manually mouse-clicking chores and were never excited at the prospect of using scripts to do the work on their behalf. I struggled to convince them to pick up scripting skills despite the evident increases in efficiency. I left that job in pursuit of a full-time software development career thereafter.

Almost a decade on working in various environments and different customers, I still encounter Windows administrators mainly possessing this general "mood" where they would avoid scripting as much as possible. Despite the increasing level of accessibility Windows server technologies are opening up for scripting and automation. I am almost certain the majority of administrators are administrators precisely because they absolutely hate performing any kind of programming duties. What are some means to encourage and motivate administrators that scripting can really help them in the long run?

Answer 1

As a Unix and Windows administrator who does a lot of Unix scripting and almost no Windows scripting, I'd say that it is in part due to the incredible awkwardness of Windows scripting utilities and APIs, and the difficulty (maybe non-obviousness would be a better word) of running things remotely on a Windows machine.

I mean, WTF is this?

Set objWMIService = GetObject("winmgmts:" _
    & "{impersonationLevel=impersonate}!\\" & strComputer & "\root\cimv2")

Part of the problem, I think, is that there is an API. Under Unix, admins are largely scripting the automation of command-line utilities they already use. Under Windows, you have to use this API that is unfamiliar on every level. For example, what does "impersonate" mean? This is a trivial concept to a Unix admin, who is likely to use sudo and su and be familiar with setuid scripts already. But a Windows admin is unlikely to be familiar with any of that; they might know about "runas" (or the equivalent GUI option), but they are far more likely to log in as an administrator when they need to do something admin-y.

And the documentation on scripting in Windows is miserable. For one thing, it's far more "interpreted language" than script, again because they are using an (unfamiliar) API and not commands that they're already familiar with. But I don't think I've ever found anything useful in Microsoft's documentation that wasn't led into by finding someone who was already doing something close to what I wanted that pointed me in the right direction. Nowhere does there seem to be a list of things-you-can-do. It's like you already have to be familiar with Windows internals in order to do the most basic things.

Not that Unix scripts don't often look like line noise. But a Unix admin can start with a script that does nothing but run simple commands that he already knows. ("I always have to run these three commands in succession. If I just put them in a file together, I can do it in one command!") And then he can later progress as he gets comfortable with the situation. In contrast, there's no way for an admin to script "log into server as administrator; click on Start → Settings → Control Panel; double-click System; click on the Computer Name tab; etc." Yeah, whatever he was trying to get to is probably presented through an API somewhere, but there's no way for him to incrementally find that.

So, to answer the question "how can we get Windows admins to do more scripting?", the answer is, make scripting less alien. How to do that, I don't know.

Honestly, the answer is in Microsoft's hands. There's no reason that they can't have a command line utility to do everything that's done via GUI. (There are actually a lot of them out there now, but they're not advertised, they're poorly documented, and they're inconsistent.) There's also no reason that there couldn't be some hint in the GUI as to what that button actually does. Have a tooltip that shows the API object that's being modified. Or document it in the Help window.

There's no problem in shielding users from the internals, but Windows seems to go out of its way to actively hide those internals, even from those who want to find them.

Answer 2

Give them a task that can really only be done through a script - for example, I once had to script the creation of hundreds of folders and custom permissions for each folder and it had to be updated DAILY. If they were to do this manually, it would be their sole job. The script, which used CACLS among other things to reset permissions based on the output of a delimited text file, took about a day to perfect (the basic script was done in about an hour).

When you start seeing what you can do with scripting, it can be a huge win.

Answer 3

I once hired a sysadmin who outright refused to do any 'programming' I tried to show him the way in leading by example. The best I could get out of him was to use existing code & modify variable assignment or host names ect. to get a job done. Some people are just not bothered with programming, so you need to lower the barrier for them.

Microsoft is making in-roads into this. In SQL Server, it's been possible for a while now to click on stuff in the Management Studio GUI & then dump out a t-sql script of what you've just done. This is great, especially for the not so programming inclined windows sysadmin.

I've noticed that System Centre Virtual Machine Manager has the same view script feature, except it dumps out a powershell script. I think many other product lines are also introducing this.

How to motivate admins into scripting? tough call, a good admin is a lazy admin & that means an admin that will script as much as possible. An admin that has the time to click on things isn't very productive! Overload your admins with so much work, that they have no choice but to script.

Answer 4

I wholeheartedly agree with your post. Unfortunately, I don't think there's much that can be done without support from management and processes in place that enforce using scripts. Given a choice, people will always go with what's familiar and what's easy. At times, this may seem like a negative point, but there are times when simplicity and familiarity is a plus.

On the one hand, the Windows system is implicitly meant to be simple/easy while Unix/Linux systems are much more difficult and less forgiving. So who can blame the admins for taking the path of least resistance? While you, or I or numerous other people may recognize the power of scripting, people will eventually learn one way or another. Typically, admins who holdout on scripting learn the hard way. I like to work smarter, others may just like to work.

What are some means to encourage and motivate administrators that scripting can really help them in the long run?

I used to think you could motivate people, but the reality is unless you're in charge of them the probability of successful "motivation" is extremely low. My attitude these days is: those who want to learn, I will help. Don't be a salesman for a product no one wants regardless of whether they need it. When you help/teach just one person who is motivated (for whatever reason), they will be the catalyst for change. Not you. Just my two cents.

Answer 5

A mantra I go by is "Work smarter, Not harder". Doing any process more than a few times means that there is usually a way you could script it out to have it done automatically with a mouse click, bash script, or other method. The way I see it, this personally frees me up to do more important tasks that are not so much the "manual labor" of system administration.

Those who want to avoid scripting may have several things running through their head. Perhaps they enjoy the GUI interface and don't want to learn command line or programming. Maybe they think that by scripting something out they are basically reducing their own self-importance. Either way, this is not the kind of employee I would like to have and a reluctance to do any sort of scripting shows what kind of worker they are. I would rather have a problem solver rather than a "dumb" system administrator.

As far as encouraging and motivating them, I would say just to do as you were doing, show the gains in productivity and how it can make their jobs easier. For some, being a Windows System Admin is just a paycheck, and it is going to be hard to motivate them to move beyond the point-and-click mentality that has worked for them the past 10 years.

Answer 6

There are a couple of issues you have to overcome, you've mentioned one, that a lot of administrators don't want to be involved in programming, even as low level as scripting. The other is related to this, and this is a matter of control. When an admin is doing a task manually they know exactly what is happening at each stage. Many administrators may feel that by replacing this with a script they are losing control over the process, particularly if they don't understand scripting, and didn't write the script (and didn't want to write it).

I think this is more of an issue with Windows admins than Unix ones as scripting has been a big part of Unix administration for a long time and is generally something Unix admins learn from the very beginning, where as Windows administration, and its inherent GUI-ness leads to a more manual process and scripting can seem unnatural.

Unfortunately getting developers over this hump is a hard battle. For the admin to still feel they are in control, they need to understand what the script is doing, and so really need to understand and learn how to script, and the only way you’re going to get them to do this is if they really understand what scripting can do to them

It’s all very well saying it'll make things quicker, make life easier etc, but can you prove it to them? Find a task that they hate, that they have to do regularly and try and automate it. If you can take this horrible task, and make it a single click script, they will love you, but more importantly they may see the benefit of using scripts.

Answer 7

[sigh] This is way too prevalent in the Windows world, although I would question your statement about the majority not wanting to pony up and learn to script. The absolute greatest thing I have ever done in my sysadmin career was to learn VB and Perl, which led to VBS, which led MANY other things.

If just showing them doesn't work to motivate, one trick I like to use is to throw out subtle statements in front of management :) Call it sucking up if you will, but it's so not. Show the decision makers the benefits, often it starts proliferating through the group. Don't be a jerk about it, though.

On a more subtle note, it's hard (if not impossible) to change someone. Lead by example!

Answer 8

This question is highly subjective. While I agree with the efficiency and increased control that scripting provides, why does it have to be a mandate? Why do you need to encourage people to use scripting just because you like to use it? Why not let people choose to use the tools they like and prefer?

This question also illustrates a common bias that exists in the IT world: That if I don't script I must not be as smart or as good as someone who does script, and that's wrong. I've known plenty of people who could script better than me, but they couldn't subnet to save their lives or figure out how run a network trace, or configure SQL server to use AWE, or didn't know what the boot.ini file was for, etc., etc.

Answer 9

Honestly, you can lead a horse to water, but you can't make him drink.

I came up as a SysAd in the Marine Corps about 10 years ago, where there is a wide gap between being an Admin and being a Coder. Being a Coder usually means that you get stuck dealing with the CO's pet project website (getting little of your actual job done...).

Because of this, I resisted learning to code, but once I decided to try it, I had a blast.

As far as drawing someone in, Try using AD/LDAP scripting to lure them in. (I think that it's a bit more accessible than dealing with WMI.) Assign a progression of tasks, say "give me the usernames and email addresses of the people in group XYZ".

I wrote this bit of code to find all users who weren't members of any of the specified groups: https://github.com/gwaldo/LDAP-Inverse-Group-Membership-Report

As far as resources, check out the Microsoft Scripting Guys (who have excellent articles and tutorials) and Scriptomatic2, which I love for digging into WMI.

Answer 10

The next question: why should they script? That will determine the answer.

Presumably, you script because it's more efficient. In that case, you can either show everybody else up, or point out to management that there's more efficient ways to administer the systems and wait for them to take advantage of that in a cost-cutting measure.

Somebody with authority can mandate scripting, by requiring that there be scripts in place to handle most things. How well this will work depends on several things; if just stated like that the scripts are likely to remain woefully inadequate and obsolete, while the admins work as normal.

There's also the question of exactly how this is affecting you. Does it just bother you, or would your life be better if your fellow admins scripted things?

Answer 11

I actually had another thought. In relation to the fact that junior Windows admins are used to GUI interactions, maybe it would help if you started them with scripting GUI interaction, with something like AutoIt. This would allow them to get their foot in the door in regards to scripting while still allowing them to use the tools they already know, instead of throwing out their existing tools and making them learn new tools and scripting at the same time.

Then, once they get comfortable with the idea of scripting in general, they can move on to non-GUI scripting. Even if not, though, automating button clicks can still potentially be a big time saver.

Answer 12

I have defined scripts as "Documentation that does the work for you."

Manager: Go spend countless hours creating documentation, that a first grader can understand, that will be stale by the end of the week, for your co-workers to clicketty-click through Task-X.

Employee: I have a script that does Task-X, could I just give them that.

Manager: Sure, after you have finished the documentation I just asked for, document your script as well, with a flow chart.

Answer 13

I have defined scripts as "Documentation that does the work for you."

Manager: Go spend countless hours creating documentation, that a first grader can understand, that will be stale by the end of the week, for your co-workers to clicketty-click through Task-X.

Employee: I have a script that does Task-X, could I just give them that.

Manager: Sure, after you have finished the documentation I just asked for, document your script as well, with a flow chart.

Don't forget that the documentation should be in an MS Word document so as to complicate reading it from the server.