Pros and cons of style standards?

["Geoff Hart (by way of \"Eric J. Ray\" <ejray -at- raycomm -dot- com>)" <ght -at- MTL -dot- FERIC -dot- CA>]

I missed the start of this thread, but here's the quote I'm
responding to: <<...from informal talks with Microsofties, it is
clear that if you want a Microsoft Certified software program (so the
logo can be carried on the package), you better follow as many of
their guidelines as possible. Especially when it comes to the GUI
used in the application.>>

Much though I hate to defend Microsoft (I'll try to regain my
credibility later in this message), they've got the right basic idea.
The rationale for insisting on conformity is a very good one: to
ensure that users only need to learn one interface, and thereafter,
they can apply it to all applications that run under Windows. Compare
this with the glory days of DOS, when everyone did whatever the heck
they felt like doing in terms of the user interface (to open files,
press Control-alt-Numlock; press shift F17 to save them), and
you'll see the power of this approach. For instance, I love the
notion that I can use control-X to cut and control-V to paste in darn
near any Windows application. Apple thought of it first on the PC
side, and enforced conformity just about as rigidly, but Microsoft
slowly followed suit and that's a good thing indeed.I can't speak
knowledgably about the mainframes that existed pre-PC, but I recall
some initiatives by IBM involving "common user architecture" or some
such buzzwords that attempted much the same thing.

Here's the part where I try to regain my credibility: The problem
with blind adherence to standards is that the standards are sometimes
pretty awful (witness Microsoft's style guide). Worse yet, this kind
of rigidity can stifle innovation. Kai Krause, for example, shocked
the heck out of the standards world by going his own way with the
interface for Kai's Power Tools (a series of Photoshop plugins). He
got away with it because the tools were so darn useful and the
interface so easy to adapt to once you figured out its logic. Others
have been far less successful. "Imitation is the sincerest form of
flattery", and there's a lot of flattery going around these days.

The trick is to follow the standard because you're aiding your users,
not because there's anything sacred about standards. You should
never be blind to the possibilities for improvement. For example, you
might include the standard File Open dialog box in your application,
because everyone knows how to use it and expects it to be there, but
if you've got a better idea, provide an icon on the toolbar that pops
up a different, far more powerful file opener (e.g., a hypertext
search engine). If your innovation is really so wonderful, people
will start using it instead of the standard interface (witness Kai's
Power Tools), your competitors will copy it in their next release,
and eventually the standards people will cave in and adopt it as part
of the standard. This strikes me as an eminently reasonable way
to do things, particularly given that it emulates the way the English
language works. I have a favorite quote that expresses this quite
nicely:

"In words, as fashions, the same rule will hold,//Alike fantastic if
too new or old://Be not the first by whom the new are tried,//Nor yet
the last to lay the old aside."-Alexander Pope

--Geoff Hart @8^{)}     Pointe-Claire, Quebec
geoff-h -at- mtl -dot- feric -dot- ca

"Patience comes to those who wait."--Anon.

 From ??? -at- ??? Sun Jan 00 00:00:00 0000=