Making software easy to use?

Every software company on the planet claims that they write user friendly
software. Some secrets as to how the HCS group does it.

I had on my business cards for more then 15 years the following
printed:

We Make Complex Systems Simple

What do we mean by the above? Well, actually it means exactly what it
says. The above means that we actually spend time studying and
analyzing the difference between hard to use software and easy to use software. We really
are usability experts. We can take a difficult task in your software and
re-write it as to make the whole task VERY easy. In fact, our goal is
that most tasks should TAKE LITTLE nor NO training.

Of course the above is just talk, so lets take a real example of what
the HCS group can do. Take the task of setting up new users and security in
ms-access. The built-in security and workgroup manager in access is fine for
a developers and software people. However, to un-leash the workgroup
security manger on a paying clients is
another matter! It is a horrible interface, and extremely confusing for
end users to have to deal with the security system.

For most of my customers the task of assigning new users and
passwords is given to some person in the company as a extra job to do.
Usually this person is the accounting person, or controller, or often it
is even the office manger who gets this task to "manage" adding to users
to their software system.

Here is the built-in screen in ms-access to edit and
manage what security options the user has:

The above is rather confusing. It is not quite apparent
that the new/delete clear password, and the group membership stuff on
the bottom part is all related. I feel sorry for the person who has
been given the task of adding, and managing users. That accounting guy, or even the
company controller is usually a very busy person, and
does not want to spend time learning the above confusing screen.

Making matters worse is a whole bunch more screens are presented
to the user for setting security. These screens again
don't make it obvious as to what the next step is.

Gosh, Read/Design, and all kinds of things that the USER DOES not
need to see. Yikes, the above is really very confusing. Lets face the
music here. The person who is going to administer this software packager
needs only the following:

Add new users

Delete users

Change passwords

Control what parts of the software system that each user can
access (ie: some new employees should NOT be able to access the
sales reports for example).

The above is a dead simple list. The secret here is to break this
task down into the above imaginary user. That that imaginary user simply needs a few basic
options to manage
their users.

Here is now my screens that
replace the above.

The above could not be more easy. You can actually just change the
user name in above screen. Note that the code behind the scenes does all the work for you.
The code actually deletes and re-creates the user for you! This
little create/delete detail is important since it eliminates the need to
train the operator that to actually change a user name you must first
delete, and then re-create a user. Developers care that you must delete
a user to change a name. However, the user of the software simply wants
to be able to change the user name, and I let them do that in the above
screen. You just simply type in a new name. Again this is the user's
mental model as to how things should work. In the above case, the user
has a different model then how ms-access actually works. To simply
ignore how users think, and un-leash how the COMPUTER works is a common
mistake that developers make. The developer will say that you can't
change a user name. The developer will tell you that you must first
delete a user, and then add the new user name. The operator of the
software will simply ask why can't I just change a user name? By
accepting the user's mental model, we eliminate any training, and we
don't have to train, tell, or worry about the operator having to "know"
about deleting users. My software simply does this delete/create behind
the scenes without the user ever knowing!

To modify
security for a user you simply hit the cute little lock button. If you want to add a new user,
you simply hit the Add new user button.

You get:

In the above you simply enter a new user name and hit ok. Note again
how I eliminate the need for funny pid codes (again, the operator does
not need to know about pid codes that ms-access security prompts for
when adding a new user). It could not be more simple to add a new user
with my software.

Now, lets take a look at the screen when you hit the modify Security Settings. When you hit the little "lock"
button, you get
the following screen:

Again, the above is so simple. You simply click on the
list of options that you want to user to have. You can go back to this
screen over time and easily add, or remove one of the security options
for this user with ease. For example, you can easily see the above user
users cannot view Seasonal Reports. The user can't delete invoice
payments either.

I have
NEVER received a support call from any of my clients as to how the above
screen is supposed work. The above is dead easy to use. In fact, ZERO
TRAINING is required. Virtually 100% of my users are able to use the
above screens the first time around without PRIOR training. In other
words, managing users and security in my applications takes no training.
Why should such a simple task take training? People are busy and have to
run THEIR BUSINESS, not learn a bunch of software on how to set
security. The
result is software that is so easy. The result is software that is a joy to
use.

Further, with the above approach I don't incur any
support costs either. Good easy to use software is such win win deal.
Any efforts to reduce training is worth heaps of gold in customer
satisfaction, and heaps in reducing support costs? What more could you
want?

HCS group does not try and re-invent the wheel.

Developers tend to be a very creative lot. When given a
blank piece of paper, developers will come up with all kinds of user
interface ideas. However, the best kept secret in the software industry
is NOT to come up with new user interfaces! There is no reason to re-invent the
wheel every time a new software package is created. When you launch ms-word, you
instantly know that you can go file->new document. When
you fire up Excel, you also know that you can go file->new document. The
same goes for most applications these days.

In other words just about every user on
the plant knows now to add something new to Word or Excel. If every user comes to expect this, then why don't
us developers follow these guide lines when developing software? Why not
leverage the mental model that current users have in regards to
software? Since almost every application does the above, then we also do
the same! Take a
look at the following menu, and note how in my application to add a new
invoice, you file->new invoice (booking)..

Everyone knows about using file->new. By adopting
industry guidelines the HCS group makes software intuitive and easy
to use.

In Word you can go edit->find, in Excel you can go
Edit->find. If you use Outlook Express, you go edit find and you get:

Well, if every piece of software you use has a
edit->Find. Then what do you think we should use when we want to search
for a invoice? Why of course edit->find invoice. So, take look at how
you find a invoice in my ms-access application:

It is important to note that each user has what we call
a mental model of how software functions. The more you can leverage
existing concepts that users have about software, the less training and
more enjoyable your software will be come. In fact, the software will be
far more intuitive as users can actually guess how things will work
BEFORE they even start a task.

The above applies to all software. The HCS group
develops software as above regardless of the development tools and
platform used. There is NO excuse for not designing first rate software
and certainly no reasons I can think of to ignore the above UI guidelines.

For a few more screen shots and notes on how searching
should work,
read the following of mine: