The development of software is still
a challenging task, which requires many technical and
organizational competencies. Most desktop applications
must implement elaborated user interfaces and access
different data bases or even internet connections. Server
applications, in turn, must cover the same functionality
with completely different technologies and, in addition,
serve several users at the same time, which puts more
emphasis on performance and user authentification. And
finally, for larger teams all this has to be embedded
into suitable development and management processes in
order to lead the many activities to the overal goal of
delivering the software.
But despite all the emphasis on
technology and processes software is still (mostly)
designed for human users which need to do their everyday
tasks with the software and are not at all enthusiastic
about the technology. Therefore, software development
should always put the ordinary user of the software into
the focus. We call this user-centric software
development.
User-centric
software development
First of all, software should provide
exactly the functionality which is necessary for the
intended use of the software or which the user expects of
the software. To achieve this, every software development
must start with a solid requirements elicitation and
analysis. After this, the required functionality must be
implemented, possibly involving a design and coding phase
and the use of the most modern IT technology. Both
aspects, requirements analysis and implementation, are
very important for a successful software development.
However, these aspects are not the only important
aspects: Software must also be easy-to-use and reliable.
User-friendly
software
Usable software should not only
provide the functionality required by the user, it should
also offer the functionality in a way which makes the
software easy to use. This concerns first of all the
aspects of user interface design, such as for example the
naming and arrangement of menu functions. But usable
software distinguishes more. It must additionally provide
sufficient help functions such that an unexperienced user
(and these are most of the users!) is able to quickly
find her way through the user interface. This includes
documentation and online help, but also supporting
functions, such as wizards and context-based hints. And
finally the software must also work intuitively and
transparently in those cases, in which the user enters
false input or something else goes wrong. In these cases,
the software must react robustly and with comprehensible
error messages.
Reliability
From the point of view of the user,
software does not necessarily have to be error-free or
nicely programmed. Software merely has to operate
reliably. If a user executes a function of the software,
then she expects that in almost all cases the software
will do what it promises to do. There is nothing more
annoying than a program which crashes or does nothing
when one needs a function very urgently.
Of course, reliability from the point
of the user implies a minimum level of software quality.
Only if the exact requirements have been elicitated and
implemented with the required level of quality, the
software is able to do exactly what the user expects. But
quality assurance should never be an end in itself.
Instead software engineers should always test exactly
those aspects of the software which are relevant to the
user. And this concerns not only the specified
functionality, but also the behavior of the software in
case of errors or different user behavior. Reliability
thus requires a user-centric quality assurance.
Our
mission
To develop software which is
user-centric and reliable is our claim and against which
we measure our software.
