Interaction Design for
Software Engineering: A Boost
into the Programming Future
Interaction design is used to create useful, usable, and desirable
software products for its users.
However, there are groups of
people who interact daily with
software products but do not
benefit from interaction design:
software developers. These are
the people that build our software, yet the tools they use are
expected change patterns and
the software developer performing the changes. When change
requirements exceed the skills or
expertise of the software developer, three symptoms can be
1. A change requires gathering
2. A change is performed at
3. A change consists of values
that depend on one another.
Conventions have an explosive
nature. As software grows, more
and more conventions overlap
with each other. Consequently,
the combinatorial interaction
among them grows exponentially.
The existence of these conventions can point toward a definition of “good software design”—
the state of software when developers can perform anticipated
changes without proliferation of
Software development suffers from longitudinal usability
issues. Software development
tools (commonly known as IDEs,
or integrated development environments) ask developers to continuously make small and seemingly unimportant decisions,
which have subtle, long-term,
and often large consequences.
Without paying attention to
“good software design,” maturing
software becomes increasingly
inert. Software design, however,
cannot be qualified as good or
bad in isolation. It is dependent
on two external factors: the
What is common to all these
symptoms is that they involve
“conventions.” A convention consists of implicit rules, which are
required to perform a change.
The existence of conventions
indicates considerable usability
Conventions are physically separated from the software. In the best
case they appear as comments or
in separate documentation. But
usually, they reside in the mind
of the software developer, subject to being forgotten.
Conventions increase cognitive
load for the software developer.
Owing to the nature of conventions, the software developer has
to apply them repeatedly. Manual
repetition provokes errors, which
need correction. Consciously
followed or not, conventions certainly create cognitive load.
When software is changed
with a focus on supporting a particular functionality, the holistic
design of the software gets out
of balance—the conventions
proliferate or become unknown.
Changes to individual pieces
of software, therefore, need to
actively anticipate the future of
“the whole” through a process
of refactoring. Refactoring is the
process of increasing software
flexibility while user visible
functionality is preserved. At