|
|
Project Results: Publications
Conferences and Workshops:
- Tutorials
- Workshop Organization
- Conference Papers
- LTSA-MSC:
Tool Support for Behaviour Model Elaboration Using Implied
Scenarios
Sebastian Uchitel, Robert Chatley, Jeff Kramer and Jeff Magee.
Proceedings of TACAS '03, Warsaw April 2003.
Abstract: We present a tool that supports the elaboration
of behaviour models and scenario-based specification by providing
scenario editing, behaviour model synthesis and model checking
for implied scenarios
.
- Model-based
Simulation of Web Applications for Usability Assessment
Robert Chatley, Jeff Kramer, Jeff Magee and Sebastian Uchitel.
Proceedings ICSE 2003 Workshop "Bridging the Gaps Between
Software Engineering and Human-Computer Interaction".
Portland (Oregon), USA, May 2003. pp. 5-11.
Abstract: In this paper we discuss an approach for
simulating the behaviour of interactive software systems,
before starting on any of the actual implementation, based
on a model of the system at the architectural level. By providing
a mock-up of the final user interface for controlling the
simulation, it is possible to carry out usability assessments
of the system much earlier in the design process than is usually
the case. This means that design changes informed by this
usability assessment can be made at this early stage. This
is much less expensive than having to wait until an implementation
of the system is completed before discovering flaws and having
to make major changes to already implemented components. The
approach is supported by a suite of cooperating tools for
specification, formal modelling and animation of the system.
- Modelling Undefined Behaviour in
Scenario Synthesis
S. Uchitel, J. Kramer and J. Magee.
2nd International Workshop on Scenarios and State Machines:
Models, Algorithms, and Tools at the 25th IEEE International.
Conference on Software Engineering (ICSE03). Portland, USA,
May 2003
Abstract: Current approaches to scenario synthesis
do not distinguish, in the resulting state machine models,
proscribed behaviour from behaviour that has not yet been
defined. In this paper we propose using partial labelled transition
systems (PLTS) to capture what remains undefined of the system
behaviour. In the context of scenario synthesis, we show that
PLTSs can be used to provide feedback to stakeholders on the
parts of the behaviour specification that need further elaboration.
In this way we aim to support the iterative incremental elaboration
of behaviour models.
- Scenario based assessment
of software architecture usability
Eelke Folmer, Jilles van Gurp, Jan Bosch.
Proceedings ICSE 2003 Workshop "Bridging the Gaps Between
Software Engineering and Human-Computer Interaction".
Portland (Oregon), USA, May 2003. pp. 61-68.
Abstract: Over the years the software engineering community
has increasingly realized the important role software architecture
plays in fulfilling the quality requirements of a system.
The quality attributes of a software system are, to a large
extent determined by the system's software architecture .Usability
is an essential part of software quality. The usability of
software has traditionally been evaluated on completed systems.
Evaluating usability at completion introduces a great risk
of wasting effort on software products that are not usable.
A scenario based assessment approach has proven to be successful
for assessing quality attributes such as modifiability and
maintainability. It is our conjecture that scenario based
assessment can also be applied for usability assessment. This
paper presents and describes a scenario based assessment method
to evaluate whether a given software architecture (provided
usability) meets the usability requirements (required usability).
The Scenario-based Architecture Level UsabiliTy Assessment
(SALUTA) method consists of five main steps, goal selection,
usage profile creation, software architecture description,
scenario evaluation and interpretation.
- Improving software
usability through architectural patterns
Natalia Juristo, Marta López, Ana M. Moreno, M Isabel
Sánchez.
Proceedings ICSE 2003 Workshop "Bridging the Gaps Between
Software Engineering and Human-Computer Interaction".
Portland (Oregon), USA, May 2003. pp. 12-19.
Abstract: This paper presents an approach for improving
final software system usability by designing for usability,
in particular by addressing usability issues in the software
architecture. This approach differs from the traditional idea
of measuring and improving usability once the system is complete.
The work presented in this paper is part of the research conducted
within the European
Union - IST STATUS related to the development of techniques
and procedures for supporting a forwardengineering approach
to improve usability in software systems at the architectural
level. In particular, we present the ongoing research about
usability
improvement by including architectural patterns that provide
solutions for specific usability mechanisms.
- Integration of Usability
Techiques into the Software Development Process
Xavier Ferre.
Proceedings ICSE 2003 Workshop "Bridging the Gaps Between
Software Engineering and Human-Computer Interaction".
Portland (Oregon), USA, May 2003. pp. 28-35.
Abstract: Software development organisations are paying
more and more attention to the usability of their software
products. To raise the usability level of the software product,
it is necessary to employ usability techniques, but their
use is far from straightforward since they are not, in most
cases, integrated with the software engineering development
processes. Offering average software developers a way to integrate
usability activities and techniques into their existing software
development process can bridge the gap between usability and
software engineering practice. The only requirement is for
the existing process to be based on iterative refinement.
We present a handy grouping of usability techniques as increments
that developers can introduce into their software development
process. We have arrived at this result by surveying the usability
literature, adapting usability concepts to software engineering
terminology, and examining the development time constraints
on the application of usability activities and techniques.
- Usability patterns in Software Architecture
Eelke Folmer, Jan Bosch
Proceedings of the 10th International Conference on Human-Computer
Interaction Volume I. HCII2003, Crete, 2003. pp. 93-97.
Abstract: Over the years the software engineering community
has increasingly realized the important role software architecture
plays in fulfilling the quality requirements of a system.
Practice shows that for current software systems, most usability
issues are still only detected during testing and deployment.
To improve the usability of a software system, usability patterns
can be applied. However, too often software systems prove
to be inflexible towards such modifications which lead to
potentially prohibitively high costs for implementing them
afterwards. The reason for this shortcoming is that the software
architecture of a system restricts certain usability patterns
from being implemented after implementation. Several of these
usability patterns are "architecture sensitive",
such modifications are costly to implement due through their
structural impact on the system. Our research has identified
several usability patterns that require architectural support.
We argue the importance of the relation between usability
and software architecture. Software engineers and usability
engineers should be aware of the importance of this relation.
The framework which illustrates this relation can be used
as a
source to inform architecture design for usability.
- A Software
Architectural View of Usability Patterns
Xavier Ferre, Natalia Juristo, Ana M. Moreno,M. Isabel Sánchez
Proc. of the 2nd
Workshop on Software and Usability Cross-Pollination: The
Role of Usability Patterns, at INTERACT 2003. Zürich,
Switzerland, September 2003.
Abstract: Usability is one of the key quality attributes
in software development. The content of this paper is part
of the research conducted within the European Union IST STATUS
project, related to the development of techniques and procedures
for improving usability of software architecture designs.
In this paper, we will focus on the possible improvement of
usability at software design time. For this purpose, we have
identified, from both the literature and the project’s
industrial partners’ experience, what we have called
usability patterns. The usability patterns represent twenty
usability mechanisms, for example, undo, cancel, multiple-languages,
etc.,
which improve final system usability and have an effect upon
the design of the software system in which they are implemented.
We also present possible design solutions for incorporating
the respective usability mechanisms into a software system
design. The design solutions have been obtained by means of
an inductive process that guarantees that these solutions
are possible, albeit not necessarily the only solutions.
- Behaviour Model Elaboration
using Partial Labelled Transition Systems
Sebastian Uchitel, Jeff Kramer, Jeff Magee
fourth joint meeting of the European Software Engineering
Conference and ACM SIGSOFT Symposium on the Foundations of
Software Engineering (ESEC/FSE), Helsinki, September 2003.
Abstract: State machine based formalisms such as labelled
transition systems (LTS) are generally assumed to be complete
descriptions of system behaviour at some level of abstraction:
if a labelled transition system cannot exhibit a certain sequence
of actions, it is assumed that the system or component it
models cannot or should not exhibit that sequence. This assumption
is a valid one at the end of the modelling effort when reasoning
about properties of the completed model. However, it is not
a valid assumption when behaviour models are in the process
of being developed. In this setting, the distinction between
proscribed behaviour and behaviour that has not yet been defined
is an important one. Knowing where the gaps are in a behaviour
model permits the presentation of meaningful questions to
stakeholders, which in turn can lead to model exploration
and thus more comprehensive descriptions of the system behaviour.
In this paper we propose using partial labelled transition
systems (PLTS) to capture what remains to be defined of the
system behaviour. In the context of scenario synthesis, we
show that PLTSs can be used to support the iterative incremental
elaboration of behaviour models.
- Modelling
a Framework for Plugins
Robert Chatley, Susan Eisenbach and Jeff Magee
SAVCBS'03 (Specification and Verification of Component-based
Systems) at ESEC/FSE '03. Sept 2003
Abstract: Using plugins as a mechanism for extending
applications to provide extra functionality is appealing,
but current implementations are limited in scope. We have
designed a framework to allow the construction of flexible
and complex systems from plugin components. In this paper
we describe how the use of modelling techniques helped in
the exploration of design issues and refine our ideas before
implementing them. We present both an informal model and a
formal specification produced using Alloy. Alloy's associated
tools allowed us to analyse the plugin system's behaviour
statically.
- Architectural Sensitive Usability Patterns
Eelke Folmer, Jan Bosch
VikingPloP workshop, September '03 Bergen
Abstract: The work presented in this paper is motivated
by the increasing realization in the software engineering
community of the importance of software architecture for fulfilling
quality requirements. Practice shows that for current software
systems, most usability issues are still only detected during
testing and deployment. Some changes that affect usability,
for instance changes to the appearance of a system’s
user interface, may easily be made late in the development
process without incurring too great a cost. Changes that relate
to the interactions that take place between the system and
the user such as, for example, usability patterns, are likely
to require a much greater degree of modification. The reason
for this shortcoming is that the software architecture of
a system restricts certain patterns from being implemented
after implementation. Several of these usability patterns
are “architecture-sensitive”, in the sense that
such modifications are costly to implement afterwards due
through their structural impact on the system. Our research
has argued the importance of the relation between usability
and software architecture. Software engineers and usability
engineers should be aware of the importance of this relation.
One of the results of this research is a collection of usability
patterns. The contribution of this paper is that it has tried
to capture and describe several usability patterns that may
have a positive effect on the level of usability but that
are difficult to retrofit into applications because these
typically require architectural support. Our collection of
patterns can be used during architectural design to determine
if the architecture needs to be modified to support such patterns.
The usability patterns identified so far can be used as requirements
during architectural design.
- Visual
Methods for Web Application Design
Robert Chatley, Jeff Kramer, Jeff Magee, Sebastian Uchitel
VMSE'03 (Visual/Multimedia Software Engineering). November
2003
Abstract: The paper outlines a tool-supported approach
to the design of Web applications. Behavioural models are
augmented with web-based simulations of user interfaces to
permit validation and usability assessment of systems by end
users in advance of implementation. The goal is to correct
architectural design decisions that adversely impact usability
early in the design cycle when correction is relatively inexpensive.
The behavioural model of a system captures the interactions
between the different users roles and the set of components
that constitute the application. A visual scenario-based language
is used to specify interactions and the tool LTSA-MSC is used
to synthesise the required behavioural model. The tool supports
a visual representation of this model that is animated in
response to user-interaction with the simulated Web interface.
The combination of these facilities permits agile incremental
elaboration of a system design.
- Model-based Verification
of Web Service Compositions
Howard Foster, Jeff Kramer, Jeff Magee, Sebastian Uchitel
Automated Software Engineering (ASE), Montreal, Canada, 2003
Abstract: In this paper we discuss a model-based approach
to verifying web service compositions for web service implementations.
The approach supports verification against specification models
and assigns semantics to the behavior of implementation models
so as to confirm expected results for both the designer and
implementer. Specifications of the design are modeled in UML,
in the form of Message Sequence Charts (MSCs), and mechanically
compiled into the Finite State Process notation (FSP) to concisely
describe and reason about the concurrent programs. Implementations
are mechanically translated to FSP to allow a trace equivalence
verification process to be performed. By providing early design
verification, the implementation, testing and deployment of
web service compositions can be eased through the understanding
of the differences, limitations and undesirable traces allowed
by the composition. The approach is supported by a suite of
cooperating tools for specification, formal modeling and trace
animation of the composition workflow.
- Patrones de Usabilidad:
Mejora de la Usabilidad del Software desde el Momento Arquitectónico
Ana M. Moreno, M. Isabel Sánchez
Actas de las VIII Jornadas de Ingeniería del Software
y Bases de Datos (JISBD 2003). November, 2003. pp. 117-126.
Abstract: La usabilidad es uno de los atributos de
calidad claves en el desarrollo de software. En este trabajo,
se presenta una aproximación para mejorar la usabilidad
de un sistema software aplicando un proceso específico
de diseño para usabilidad. El contenido de este artículo
forma parte de una investigación llevada a cabo dentro
del proyecto de la Unión Europea IST STATUS, relacionado
con el desarrollo de técnicas y procedimientos para
mejorar la usabilidad, desde momentos tempranos del desarrollo
de software. Esta aproximación difiere de la idea tradicional
de medir y mejorar la usabilidad una vez finalizado el sistema.
En este trabajo nos centraremos en la posible mejora de la
usabilidad en el momento de diseño de software. Para
ello, se ha identificado, a partir de la literatura y de la
experiencia de los socios industriales del proyecto, lo que
se ha denominado patrones de usabilidad. Los patrones de usabilidad
representan veinte mecanismos de usabilidad, por ejemplo,
deshacer, cancelar, múltiples idiomas, etc., que mejoran
la usabilidad del sistema final y que tienen un efecto en
el diseño del sistema software donde se implante. Junto
con estos patrones de usabilidad, también se presentan
posibles soluciones de diseño para incorporar los mecanismos
de usabilidad correspondientes en el diseño del sistema
software. Las soluciones de diseño se han obtenido
por medio de un proceso inductivo que garantiza que éstas
son posibles soluciones aunque no tienen porque ser únicas.
- Exploiting
Architecture in Scenario-Based Model Synthesis
Sebastian Uchitel, Robert Chatley, Jeff Kramer, Jeff Magee
Submitted to ICSE'04 (International Conference on Software
Engineering) April 2004
Abstract: Constructing rigorous models for analysing
the behaviour of concurrent and distributed systems is a complex
task that requires expertise in formal languages and their
semantics. Our aim is to support the construction of behaviour
models. In this paper we combine a scenario synthesis approach
with an architecture description language to automatically
build behaviour models. The scenario synthesis provides simple,
intuitive, example based description of behaviour of component
instances in a specific architecture instance. The architecture
description gives the necessary information for component
instance behaviour to be generalised to component type behaviour.
It can also provide the potential architecture in which the
generalised behaviours could be instantiated. Exploiting architecture
in scenario-based model synthesis allows the construction
of significantly more complex system models. Further, it supports
model elaboration by instantiating the behaviour described
in simple architectures in more complex ones.
- Architecture-Level Usability Assessment
Eelke Folmer, Jilles van Gurp, Jan Bosch
Submitted to ICSE'04 (International Conference on Software
Engineering) April 2004
Abstract: Studies of software engineering projects
show that a large number of usability related change requests
are made after its deployment. Fixing usability problems during
the later stages of development often proves to be costly,
however. Many of the necessary changes require changes to
the system that cannot be easily accommodated its software
architecture. The successful development of a usable software
system therefore must include creating a software architecture
that supports the right level of usability. Unfortunately,
no architecture level usability assessment techniques exist.
As a consequence, the usability impact of architecture level
changes is hard to predict. This paper presents a scenario
based assessment technique that allows evaluation of the architecture’s
support of usability that has been successfully applied in
several cases. Explicit evaluation of usability during architectural
design reduces the risk of building a system that fails to
meet its usability requirements and may prevent high costs
incurring adaptive maintenance activities once the system
has been implemented.
- Fluent-Based
Animation: Exploiting the Relation between Goals and Scenarios
for Requirements Validation
Sebastian Uchitel, Robert Chatley, Jeff Kramer, Jeff Magee
RE (Requirements Engineering) 2004
Scenarios and goals are effective and popular techniques for
requirements definition. Validation is essential in order
to ensure that
they represent what stakeholders actually want. Rather than
validating scenarios and goals separately, possibly driving
the elaboration of one through the validation of the other,
this paper focuses on exploiting the relation between goals
and scenarios. The aim is to provide effective graphical animations
as a means of validating both. Goals are objectives that a
system is to meet. They are elaborated into a structure that
decomposes declarative goals into goals that can be formulated
in terms of states controllable by the system. Scenarios are
operational examples of system usage. The relation between
scenarios and goals is established by means of fluents that
describe how events of the operational description change
the state of the basic propositions from which goals are expressed.
Graphical animations are specified in terms of fluents and
driven by a behaviour model synthesised from the operational
scenarios.
- Predictable
Dynamic Plugin Systems
R. Chatley, S. Eisenbach, J. Kramer, J. Magee, and S. Uchitel
FASE (Fundamental Approaches to Software Engineering) 2004
To be able to build systems by composing a variety of components
dynamically, adding and removing as required, is desirable.
Unfortunately systems with evolving architectures are prone
to behaving in a surprising manner. In this paper we show
how it is possible to generate a snapshot of the structure
of a running application, and how this can be combined with
behavioural specications for components to check compatability
and adherence to system properties. By modelling both the
structure and the behaviour, before altering an existing system,
we show how dynamic compositional systems may be put together
in a predictable manner.
- System
Architecture: the Context for Scenario-based Model Synthesis
Sebastian Uchitel, Robert Chatley, Jeff Kramer, Jeff Magee
SIGSOFT 2004/FSE-12
Constructing rigorous models for analysing the behaviour of
concurrent and distributed systems is a complex task. Our
aim is to facilitate model construction. In this paper we
combine a scenario synthesis approach with an architecture
description language (ADL) to provide automated support for
model construction. Scenarios provide simple, intuitive, example
based descriptions of the behaviour of component instances
in the context of a simplified architecture instance. The
specific architecture instance is generally chosen to provide
sufficient context to allow giving examples of how instances
of the component types used in the real system are expected
to behave. Existing synthesis techniques provide mechanisms
for building behaviour models for these simplified and specific
architectural settings. However, the behaviour models required
are those for the full generality of the system architecture,
and not the simplified architecture used for scenarios. Software
architecture descriptions give the necessary contextual information
so that component instance behaviour can be generalised to
component type behaviour. Furthermore, ADLs can be used to
describe the complex architectures in which the generalised
behaviours need to be instantiated. Thus, architectural information
used in conjunction with scenario-based model synthesis can
support both model construction and elaboration, where the
behaviour derived from simple architecture fragments can be
instantiated in more complex ones.
- MagicBeans:
a Platform for Deploying Plugin Components
Robert Chatley, Susan Eisenbach and Jeff Magee
Component Deployment '04
Plugins are optional components which can be used to enable
the dynamic construction of flexible and complex systems,
passing as much of the configuration management effort as
possible to the system rather than the user, allowing graceful
upgrading of systems over time without stopping and restarting.
Using plugins as a mechanism for evolving applications is
appealing, but current implementations have limited functionality.
In this paper we present a framework that supports the construction
and evolution of applications with a plugin architecture.
- Clarifying the Relationship between
Software Architecture and Usability
Natalia Juristo, Ana M. Moreno, Maria Isabel Sánchez
Sixteenth International Conference on Software Engineering
and Knowledge Engineering (SEKE'04)
This paper examines in a problem posed recently concerning
the relationship between software system usability and architecture.
Here, we try to empirically clarify this relationship, focusing
on the concept of architecture-sensitive usability mechanism.
This concept represents specific usability issues that can
improve software usability and that have demonstrated architectural
implications. Accordingly, this paper outlines how usability
needs to be decomposed to be dealt with from an architectural
point of view and how the architecture-sensitive usability
mechanism emerges. A list of architecture-sensitive usability
mechanisms is presented and the procedure for outputting their
respective architectural implications is discussed.
- Architecture-Level Usability
Assessment
Eelke Folmer, Jilles van Gurp, Jan Bosch
EHCI, Hamburg, July 2004.
Studies of software engineering projects [1,2] show that a
large number of usability related change requests are made
after its deployment. Fixing usability problems during the
later stages of development often proves to be costly, since
many of the necessary changes require changes to the system
that cannot be easily accommodated by its software architecture.
These high costs prevent developers from meeting all the usability
requirements, resulting in systems with less than optimal
usability. The successful development of a usable software
system therefore must include creating a software architecture
that supports the right level of usability. Unfortunately,
no architecture-level usability assessment techniques exist.
To support software architects in creating a software architecture
that supports usability, we present a scenario based assessment
technique that has been successfully applied in several cases.
Explicit evaluation of usability during architectural design
may reduce the risk of building a system that fails to meet
its usability requirements and may prevent high costs incurring
adaptive maintenance activities once the system has been implemented.
- Cost Effective Development
of Usable Systems; Gaps between HCI and SE
Eelke Folmer, Jan Bosch
ICSE Workshop "Bridging the Gaps Between Software Engineering
and Human-Computer Interaction-II", Edinburgh, Scotland,
May 2004.
Usability is considered an important quality attribute for
software systems. To ensure a particular level of usability,
a certain amount of time and money have to be invested; however
this has proven to be expensive. Most of the costs spent on
usability are spent after an initial development e.g. during
maintenance. These high costs often prevent developers from
meeting all the usability requirements. The challenge is therefore
to cost effectively develop usable software e.g. minimize
the costs & time spent on usability. We believe architecture
analysis of usability is an important tool to achieve this.
Our experiences with software architecture analysis of usability
allowed us to identify a series of problems that explain why
usability is not achieved cost effectively in current software
development practice.
- Submission to
ICSE Workshop "Bridging the Gaps Between Software Engineering
and Human-Computer Interaction-II", Edinburgh, Scotland,
May 2004.
Lisette Bakalis, Eelke Folmer, Jan Bosch
- Experiences with Software Architecture
Analysis of Usability
Eelke Folmer, Jan Bosch, Experiences with Software Architecture
(submitted to the Journal of Software Maintenance June 2004)
Studies of software engineering projects show that a significant
large part of the maintenance costs of software systems is
spent on dealing with usability issues. Fixing usability problems
during the later stages of development has proven to be costly
since many changes cannot be easily accommodated by the software
architecture. These high costs prevent developers from meeting
all the usability requirements, resulting in systems with
less than optimal usability. Explicit evaluation of a software
architecture for its support of usability is a tool to cost
effectively develop usable systems. It allows for more "usability
tuning" on the detailed design level, hence, preventing
part of the high costs incurred by adaptive maintenance activities
once the system has been implemented. Based on our
investigations into the relationship between usability and
software architecture, we developed a Scenario based Architecture
Level UsabiliTy Analysis technique (SALUTA). The contribution
of this paper is that it provides experiences and problems
we encountered when conducting architecture analysis of usability
at three industrial case studies performed in the domain of
web based enterprise
systems (e.g. e-commerce-, content management- and enterprise
resource planning systems). We make some general observations
and some architecture assessment related observations. For
each experience, a problem description, examples, causes,
solutions and research issues are identified.
Journal Papers:
- Improving Software Engineering
Practice with HCI Aspects
Xavier Ferre, Natalia Juristo, Ana M. Moreno
Software Engineering Research and Applications
Lecture Notes in Computer Science
Vol 3026, pp. 349-363.
Abstract: Techniques from the HCI (Human-Computer Interaction)
field have been used for the development of usable software products
for a long time, but their use is often not integrated with software
engineering practices. In this work we describe an approach for
bridging the gap between software engineering and HCI, by offering
orientation to software practitioners on the application of HCI
techniques and activities. For this purpose, we have carried out
a survey in HCI literature to define the activities in a user-centered
development process, and to select the HCI techniques that are
more appropriate for integration into software engineering practice.
- Architecting for usability: A Survey
Eelke Folmer, Jan Bosch
Journal of systems and software. issue 70-1, 2004. pp. 61-78.
Abstract: Over the years the software engineering community
has increasingly realized the important role software architecture
plays in fulfilling the quality requirements of a system. Practice
shows that for current software systems, most usability issues
are still only detected during testing and deployment. To improve
the usability of a software system, usability patterns can be
applied. However, too often software systems prove to be inflexible
towards such modifications which lead to potentially prohibitively
high costs for implementing them afterwards. The reason for this
shortcoming is that the software architecture of a system restricts
certain usability patterns from being implemented after implementation.
Several of these usability patterns are "architecture sensitive",
such modifications are costly to implement due through their structural
impact on the system. Our research has identified several usability
patterns that require architectural support. We argue the importance
of the relation between usability and software architecture. Software
engineers and usability engineers should be aware of the importance
of this relation. The framework which illustrates this relation
can be used as a source to inform architecture design for usability.
- Investigating
the relationship between software architecture and usability
Eelke Folmer, Jilles van Gurp, Jan Bosch
Accepted for Software Process - Improvement & Practice: Special
Issue on Bridging the Process and Practice Gaps between Software
Engineering and Human Computer Interaction, 2003
Abstract: Usability is increasingly recognized as an essential
factor that determines the success of software systems. Practice
shows that for current software systems, most usability issues
are detected during testing and deployment. Fixing usability issues
during this late stage of the development proves to be very costly.
Some usability improving modifications such as usability patterns
may have architectural implications. We believe that the software
architecture may restrict usability. The high costs associated
with fixing usability issues during late stage development prevent
developers from making the necessary adjustments for meeting all
the usability requirements. To improve upon this situation we
have investigated the relationship between usability and software
architecture to gain a better understanding of how the architecture
restricts the level of usability. Our paper makes a number of
contributions; a framework is presented that expresses the relationship
between usability and software architecture. The framework consists
of an integrated set of design solutions such as usability patterns
and usability properties that have been identified in various
cases in industry, modern day software, and literature surveys.
These solutions, in most cases, have a positive effect on usability
but are difficult to retrofit into applications because they have
architectural impact. Our framework may be used to guide and inform
the architectural design phase. This may decrease development
costs by reducing the amount of usability issues that need to
be fixed during the later stages of development.
Book Chapters:
-
Integration of HCI Practices into Software Engineering Development
Processes: Pending Issues
Xavier Ferre, Natalia Juristo, Ana M. Moreno
In press.
Encyclopedia
of Human-Computer Interaction Edited by Claude Ghaoui
Idea Group Reference, 2005.
The usability of a software product has become a highly relevant
issue for the software industry. Nonetheless, there tends to
be very little integration of usability-related activities and
techniques into software engineering development processes.
This article discusses how the view taken of usability has evolved
in the software engineering field, where there is an increasing
demand for the application of usability practices throughout
the development process. The aim of a tighter integration of
HCI (Human-Computer Interaction) techniques and activities into
the development process is hindered by the terminology breach
and by misconceptions in the integration approach. These obstacles
are analyzed from a software engineering viewpoint, and a possible
solution is outlined.
- Which, When and How Usability Techniques and Activities Should
Be Integrated
Xavier Ferre, Natalia Juristo, Ana M. Moreno
In press
Human-Centered
Software Engineering: Integrating Usability in the Development
Process. Edited by Ahmed Seffah, Jan Gulliksen and Michel
Desmarais
Springer-Verlag, 2005.
Software development organizations are paying more and more attention
to the usability of their software products, as increasing importance
is attached to usability as a critical software quality attribute.
The HCI (Human-Computer Interaction) field offers techniques aimed
at producing a software product with a good usability level, but
their use is often not integrated into SE (software engineering)
development processes. The integration of usability techniques
into SE practice is not an easy endeavor, since both fields speak
different languages and deal with software development from different
perspectives. This chapter presents a framework for the integration
of usability techniques and activities. This framework characterizes
selected usability techniques and activities using SE terminology
and concepts, according to what kind of activity they belong to
and at what development stage their application contributes most
to the usability of the final software product. Software developers
may then manage usability activities and techniques, include them
in their software process, and understand in which activities
usability and SE techniques have to be merged to achieve concurrent
objectives. The proposed framework is aimed at software development
organizations with a defined iterative development process that
are looking to enhance their process with usability aspects.
|
