When I build software I always do it aligned with a model. The model
evolves with the software and in many
cases defines the boundaries of what can and can't be done (that is without modifying
or breaking it). A good model is one which is simple to understand yet powerful
enough to allow the introduction of new features.
A good model makes me happy. If it was developed by me then it will be
the first thing I will show when presenting my work. If it is others it will be
the first things that will make me appreciate their work. Actually I think so
high on the importance of a good model that I have made the mistake of asking my
users to learn it too.
Users obviously view the world through their eyes. In places you might
recognize several use cases as the same one, your users might see them as
completely different cases.
It seems I am not the only one taking this approach. Remember the first
days of Android OS. One of the first things they were proud of was: "Everything
is an application". Indeed as a Software Engineer the fact that every functionality
on top of the operating system is modeled as an application is simple yet powerful.
But as a user I always moved uncomfortably in my chair when pressing on the
applications button and find the Phone application there. You see, as a user I
have a phone device with phone related functions and I have the applications
which is an extension to the phone. Finding the phone icon and contacts icon in
the applications section confused me. Especially in the early days of Android
where the phone application shortcuts was permanent. IPhone OS took a different
approach where some of the device functionality was presented to the user as OS
features (e.g. Siri,).
Another example is the JavaScript language and Object Oriented Paradigm.
In this example the user is the JavaScript developer trying to use it as an
Object Oriented language. Again you have a powerful simple model (everything is
a function) which enables you to implement any Object Oriented principle. However,
each concept requires a special usage of the model (Hint: want to define a
class? use a function).
On the other hand Java takes a different approach. One example that comes
to mind are the Enums introduced in Java 5. Although one can easily implement
an Enum (see http://www.javacamp.org/designPattern/enum.html) they still
decided to include it in the language.
What is the correct approach? Taking the first approach, in which the
model is generic and it is also introduced to the user, is cheaper and easier
to develop. Yet it will produce a less friendly software. So I believe the key
consideration here is: Who is your user and will he be able to learn and adapt?
Recently I have started to adopt a hybrid approach. I expose both the
general powerful model to the advanced user and a simple domain oriented
interface for the average user.
To sum things up I highly recommend (especially for developers) to pay
attention to the difference in the point of view of users vs. the model. Moreover,
to decide on the correct approach consider both the user nature and your resources.
