Last week I had to handle a couple of requests for new projects to be added to our bug tracking system, because adding new projects requires administrative privileges. In both cases, I wound up just giving the people who made the requests administrator privileges themselves, but I was reluctant to do so.
The thing is, my reluctance had nothing to do with not trusting the people in question, it was strictly due to the psychology of using the software. We have maybe ten people who use the system, and after promoting two more administrators, I think seven or eight of the users are administrators. Given a system that provides various access privileges, it felt odd to me to basically let everyone be an administrator. There’s a little voice in my head that said that maybe only 25% of the users of a system should be at the top, and honestly I’m not sure where that comes from.
What I find interesting about that is that when I’m using a wiki, I love the fact that all of the users can do whatever they want — edit anything, delete articles, and generally make a mess of things. So I can’t help but think that the simple existence of user roles drives me to think in terms of those roles and who should be in them.
I think there’s something deep here about the way software is designed. When you provide users with features that define structure in some way, there is some compulsion to adhere to that structure, whether or not it makes sense. If your mail system provides folders, people feel like they ought to organize their mail in folders. If your bug tracking system provides a highly granular system of access control, people feel like they ought to assign privileges in that way.
That’s the reason Google was so reluctant to include a “delete” function in Gmail. They wanted to relieve users of the “delete” or “keep” decision when it comes to every email message. They give you plenty of space and make it easy to just archive your mail. Don’t bother filing it, and don’t try to figure out whether it’s something you need to keep. Of course, they added the “delete” function after users clamored for it, but I think that leaving it out was a pretty interesting experiment.
These considerations add a layer of complexity to software design. As developers, we tend to think of adding new features simply as adding optional ways of usage that users can ignore, but there’s more to it than that. As users, we feel like we should use the options that are provided to us, whether it makes sense or not. I suspect this is one of the reasons for software spoilage.