Conference PaperPDF Available

Modelling Agile Requirements using Context-based Persona Stories


Abstract and Figures

In recent years hybrid approaches focusing on user needs by integrating Agile methodologies (e.g. Scrum, Kanban or Extreme Programming) with Human-Centered Design (HCD) have proven to be particularly suitable for the development of Web systems. On the one hand, HCD techniques are used for requirements elicitation and, on the other hand, they can be utilized to elicit navigation relationships in Web projects. Navigation is one of the basic pillars of Web systems and also a fundamental element for the methodologies within the Model-Driven Web Engineering (MDWE) field. This paper presents an approach to model Agile requirements by means of integrating HCD techniques into Agile software development. We contribute to the software development body of knowledge by creating the concept of a Context-based Persona Story (CBPS) and formalizing it through a metamodel. Our approach covers the modeling of users and stakeholders by personas as well as the visualization of the context of use by storyboards. The attributes of the context of use enable us to elicit acceptance criteria for describing the scope of an Agile requirement.
Content may be subject to copyright.
Modeling Agile Requirements using Context-based Persona Stories
Jorge Sedeño1, Eva-Maria Schön2, Carlos Torrecilla-Salinas3, Jörg Thomaschewski4, Maria José
Escalona3, and Manuel Mejias3
1Agencia Andaluza de Instituciones Culturales and University of Seville, Seville, Spain
2CGI, Hamburg, Germany and University of Seville, Spain
3Department of Computer Languages and Systems, University of Seville, Seville, Spain
4University of Applied Sciences of Emden/Leer, Emden, Germany
{jorge.sedeno, eva.schoen, carlos.torrecilla},, {mjescalona ,
Keywords: User Involvement, User Experience Design, Human Computer Interaction, Assistive Technologies, Agility
in IS Development, Model-Driven Web Engineering, User Centered Design, Personas, User Stories, Agile
Software Development.
Abstract: In recent years hybrid approaches focusing on user needs by integrating Agile methodologies (e.g. Scrum,
Kanban or Extreme Programming) with Human-Centered Design (HCD) have proven to be particularly
suitable for the development of Web systems. On the one hand, HCD techniques are used for requirements
elicitation and, on the other hand, they can be utilized to elicit navigation relationships in Web projects.
Navigation is one of the basic pillars of Web systems and also a fundamental element for the methodologies
within the Model-Driven Web Engineering (MDWE) field. This paper presents an approach to model Agile
requirements by means of integrating HCD techniques into Agile software development. We contribute to
the software development body of knowledge by creating the concept of a Context-based Persona Story
(CBPS) and formalizing it through a metamodel. Our approach covers the modeling of users and
stakeholders by personas as well as the visualization of the context of use by storyboards. The attributes of
the context of use enable us to elicit acceptance criteria for describing the scope of an Agile requirement.
Agile approaches can be seen as an evolution of the
previously existing iterative and incremental
approaches, with the objective of providing
organizations with tools to quickly adapt to changing
requirements and also to ensure the early value-
delivery of results to business. Agile is as a label
grouping different frameworks and methodologies
sharing a common set of principles and values that
can be found in what is known as “Agile Manifesto”
(Beck et al., 2001). Some examples of Agile
approaches are Lean Software Development
(Poppendieck and Poppendieck, 2003), Scrum
(Sutherland and Schwaber, 2011) eXtreme
Programming (XP) (Beck, 2000) or Kanban
(Anderson, 2010). Besides, Web systems are those
developed to be published and consumed on the
Internet, being the subject of study of Web
Engineering (Desphande et al., 2002). This field can
be defined as the systematic, quantifiable and
structured application of methodological approaches
to development, evaluation and maintenance of Web
systems (Desphande et al., 2002). The navigational
model, which defines how users can navigate
through the information, is a basic element in Web
Engineering approaches (Valderas and Pelachano,
2011), especially in requirements elicitation and
analysis phases.
Web-based systems are characterized, among
other aspects, by flexible approach to requirements
and quick user-feedback, in order to easily adapt and
adjust to changing needs (Hu et al., 2008). Besides,
Web-based development has also special
characteristics that differentiate it from other type of
development projects, such as: complex navigational
structure (Escalona and Aragon, 2008), (Escalona et
al., 2004) or quick adaptation to changing
requirements (Mendes and Mosley, 2005)
(Pressman, 2000) (Reifer, 2000). The latter is
becoming a key success factor in Web-based
systems. As it is known, one of the principles of
Agile methodologies is embracing changes (Beck et
al., 2001), thus Agile approaches might offer a
suitable framework for the exposed Web
development characteristics (Hu et al., 2008).
The classical approach to requirements is based
on an up-front detailed requirements engineering
phase. This kind of approach demands a stable
environment, which is not often the case in Web
projects, as requirements might have a fluidic scope
(Mendel and Mosley, 2005) (Pressman, 2000). The
incremental and iterative way of processing
requirements that Agile approaches provide (Dyba et
al., 2008) may better fit this particular case. There
are examples, as the one described by Torrecilla-
Salinas et al. (Torrecilla-Salinas et al., 2015) that
shows successful application of Agile approaches to
Web environments.
One of the main changes that Agile approaches
bring is the move from a plan-driven deliverable
centered approach to a value-driven one (Schön et
al., 2017), in which human interactions become a
relevant element, as the Agile manifesto (Beck et al.,
2001) states. In this context, Agile proposes several
approaches to requirements, among which user
stories (Cohn, 2004) and personas (Cooper, 1999)
(Maguire, 2013) are some of the most popular ones.
On the one hand, user stories technique represents a
way to express user needs in an “in-formal” way,
which allows discovering the details of the
requirement through interactions with customers or
their representatives at the same time functionality is
developed. On the other hand, persona technique
depicts an imaginary person that will represent a
certain target group of users. It is a common
approach on Agile projects to refine user roles and
user profiles. Several authors propose the
combinations of these two techniques into what is
called “Persona-driven user stories” (Winter et al.,
2012), which tries to combine user needs and user
profiling simultaneously.
Our paper goes a step forward to this approach,
by including in addition to the “need” (user story)
and “who” has this need (persona), the “context”
where this need appears (Context of Use, ISO 9241-
210, 2010). This can be defined as Context-based
Persona Story (CBPS).
Based on the foregoing, our paper has the
following goals:
§ Define CBPS concept.
§ Illustrate, by means of different proposed
techniques, how CBPS can be elicited.
§ Propose a metamodel to formalize the
definition of CBPS.
§ Draft meaningful conclusions and suggest
further lines of research.
For this purpose, it is organized into the
following sections: after this introduction, Section 2
will offer a view of the related work. Afterwards,
Section 3 will describe, through an example, how to
obtain CBPS and it will also present the proposed
metamodel. Section 4 will define the limitations of
the model, and finally Section 5 will draft the main
conclusions of the paper and will propose further
lines of research.
User stories have their origin in eXtreme
Programing (XP) (Beck, 2000). They consist of
three essential elements (Cohn, 2004) (Jeffries,
2001): the written part, which is used as a reminder
to the requirement; the conversation around the
story, which supports building shared understanding;
and the acceptance criteria, which serve as
boundaries for the scope of a story. During the last
years, this established schema of user story has
evolved. In the field of Human-Centered Agile
Development (HCAD), different types of user
stories exist that aim to describe requirements from
users perspective considering their needs and
Cohn (Cohn, 2004) suggests replacing the role
of story with persona. The benefits of the integration
of persona are also discussed in Winter et al. (Winter
et al., 2012) and Jeffries (Jeffries, 2001). Personas
support the project team to gain common
understanding concerning user and stakeholder, as
well as their needs and behaviors by utilizing them
as actors in user stories. The concept of persona
stories is also discussed by Hudson (Hudson, 2013).
He stresses that personas assist understanding how
and when tasks are performed. In addition, he states
that one of the main benefits is that their resulting
scenarios and visual designs are prescriptive by
means of doing user research rather than just
guessing how users will interact with the system.
Näkki (Näkki et al., 2011) recommends using
“needs-based user stories”. They collect users
everyday needs and challenges regarding a specific
domain to create this type of stories. Furthermore,
Näkki et al. involve users during requirements
elaboration, by commenting and rating features in
order to allow prioritization.
Harbers (Harbers et al., 2015) introduces the
concept of “value-based user stories", which are
created during a “Value Story workshop”, where
different stakeholders participate. This contribution
enables stakeholder values to be embedded into
Analyzing the existing work, we can conclude
that there are multiple ways of including user and
stakeholder needs into system development by using
persona stories, needs-based user stories or value-
based user stories. One common goal of these
approaches is making Agile Software Development
(ASD) more human-centric. However, one major
gap they share is not considering that value or needs
might vary, even from the same user type,
depending on the context in which the story is
executed. We can therefore conclude that the related
work lacks in defining this context of use (ISO
9241-210, 2010), which usually plays an important
role when it comes to estimating and prioritizing
requirements. Taking into account the attributes of
the context of use (users, tasks, equipment and
physical and social environments in which a system
is used) enables us to elicit the acceptance criteria of
a persona story and also to give it a scope. To this
end, and as main contribution, we introduce the
concept of “Context-based Persona Stories” (CBPS).
On the one hand, needs and values are covered by
using personas; on the other hand, the context of use
is comprised by means of a storyboard.
Our proposed model will include all the specific
goals of Web systems requirements engineering:
identification of content requirements, identification
of functional requirements in terms of navigation
needs and businesses processes, and definition of
interaction scenarios for different groups of Web
users (Escalona and Koch, 2007).
As it has been mentioned, we propose the CBPS
approach that will allow us to formalize the
aforementioned objectives by taking users needs and
stakeholders value as our starting point, and by
utilizing, in a coordinated way, a set of Agile
techniques that will ensure the involvement of users.
In this section, we will present our proposal by
introducing the application of persona technique to
model user needs and values and explaining how to
identify the context of use by means of storyboards.
Later, we will describe the formalization of CBPS
and finally we will introduce a metamodel
representing CBPS Agile requirements.
The next sections will illustrate an example of
how to identify the modeled CBPS by means of
different Agile techniques.
3.1 Modeling User Needs and
Stakeholder Values
Personas are used as representatives of real users
during system development in HCD (Cooper, 1999),
(Pruitt and Adlin, 2010). They became an
established artifact in the Agile community during
the past years. Persona specifically describes a
potential user of the system to be developed and it
represents a larger part of the target group. In
addition to modeling users through personas, we can
also use this technique for modeling stakeholders.
One of their main contributions to system
development is enabling project members to
generate an empathetic focus on user needs and
values (Pruitt and Adlin, 2010). It allows preventing
self-referential design, where project members lead
their own needs and motivations to the user.
Figure 1 presents an example of persona. It
shows how a representative of the Andalusian civil
servant community is modeled by deeply identifying
his character, behavior and motivations.
Additionally, elements like the way the application
is consumed (e.g. What devices does it use? When
and how often it is used?) are included in the
definition of persona.
3.2 Modeling Context of Use
Storyboards can be used to visualize the workflow
and user-system interaction (Truong et al., 2006).
They consist of a sequence of pictures, which show
significant steps of the workflow. In particular, they
support visualizing the conditions of Web projects
(e.g. light conditions and connection to the Internet
by means of connection type and bandwidth) and
they can be linked to one or more personas. Thus,
storyboards can be used to model the context of use
as defined by ISO (ISO 9241-210, 2010). This
context of use is composed of users, tasks,
equipment (hardware, software and materials), and
physical and social environments in which the
product is used.
Figure 1: Example of a persona providing photo, personal information (e.g. name, age or nationality, among others) and
data regarding user behavior, motivation and pain points.
Figure 2 shows an example of a storyboard named
"requesting a sight visit", which shows the workflow
associated with how a citizen of Andalusia gets
permission to a sight. On the one hand, it displays
the users who are involved in the process and the
interactions among them; on the other hand, it shows
how to communicate with the software they use
through a storyboard. As seen, the already defined
personas are the actors of our story in the storyboard
with the aim of representing graphically the context
where the application is used.
Figure 2: Example of a storyboard in the area of E-
government describing the workflow to get permission for
a tourist visit.
3.3 Creating Context-based Persona
In Agile Software Development user stories are
utilized in order to describe the functional
requirements of a system from users viewpoint,
according to a specific format as shown below:
As a <role>, I want < feature> so that I can
achieve <goal>
As discussed above, this formal representation of
a user story lacks in defining a specific user, his/her
needs and the environment in which the specified
feature of the story is applied. To this end, we
recommend using CBPS instead of this well-known
format. Firstly, we can model users, stakeholders
and their needs by including the information given
by our already defined personas. Secondly, we can
take into account the context of use represented by
our storyboards.
Our metamodel (see Figure 4) offers support by
means of formalizing CBPS as follows:
<Persona> in the <Context of Use>, wants
to achieve <Goal>, so that <benefit>
Based on the information provided by personas
and storyboards, we can create these CBPS (as
Figure 3 shows). This approach allows connecting
the functionality described by different CBPS to
each other and we can declare how interaction
among different personas takes place in order to
achieve one common business objective (“reduce
processing time of a case”).
Figure 3: Example of CBPS.
3.4 Metamodel for a Context-based
Persona Story
The aforementioned objectives in section 3 can be
formalized by an UML metamodel representing an
Agile requirement, which is shown in Figure 4. It
describes the relationships between the main Agile
artifacts and includes the key elements and
relationships of a CBPS.
As Figure 4 displays, three key entities can be
found in the metamodel: “User Story”, “Persona”
and “Navigation Relationships”.
Together with the key entities, the metamodel
will include the minimum and mandatory set of
attributes that will allow a real understanding of the
modeled Agile requirement. The main goal is to
obtain a set of requirements as much homogeneous
and complete as possible at a certain moment of the
development process. Our metamodel enables us to
define the meaning of homogeneity and
completeness by means of a set of attributes. Among
them, we will now highlight the following ones:
§ From the ones related to User Storyentity,
we would like to point to those like business
value, size and ROI (Return Of Investment)
that will help order and prioritize the list of
Agile requirements. User Story entity
describes a value-based perspective of a
particular user need by means of the ROI
attribute. This attribute is calculated as the
result of dividing Story business value (the
value it brings to the business, given by the
business representatives) by Story size (how
much building the story will cost, indicated by
the development team). We can also find
Acceptance Criteria and Definition of
Done entities, linked to “User Story”. They
will allow better defining the boundaries of
each user need in order to narrow its scope.
§ From the ones related to Persona” entity, we
would like to refer to those making possible
the differentiation among the diverse types of
users and stakeholders and the relationships
between them and the identified user stories
(like motivations or personal information).
The metamodel also includes the mandatory
attributes that describe in-depth “Context of
Use”, defining the environmental aspects (e.g.
physical or social environment in which the
functional need is present). Linked to
Persona entity, we can also find UI
Graphic Elements entity, which will help
better describe the functionality contained in
user stories. This supports a formal description
of the navigation within the system, expressed
as an interaction of users (represented by
Persona entity) with their needs
(represented by “User Story” entity).
§ From the ones related to “Navigation
Relationship” entity, we would like to remark
those associated with the navigational model.
These attributes represent the interactions
between personas and user interface graphical
elements (as wireframes or mock-ups) to
materialize a particular User Story.
As it can be seen, the metamodel has helped us
cover the above-mentioned three goals of Web
Systems requirements elicitation phase:
identification of content requirements (by means of
“User Story”, “Acceptance Criteria” and
“Definition of Done” entities), identification of
functional and non-functional requirements in terms
of navigation needs and businesses processes (by
means of “Navigational Relationships” and “UI
Graphic Element”, and their relationships with
“User Story” entity), and definition of interaction
scenarios for different groups of Web users (by
means of “Persona” and “Context of Use” entities).
Figure 4: Context-based Persona Story Metamodel.
3.5 An Example in the Industry
It was in between 2008-2012 that the Regional
Ministry of Culture of Andalusia, Spain, (Junta de
Andalucía, España) transformed itself into an
organization able to operate under SOA paradigm,
but it was in between 2012-2015 that it started using
an own Agile methodology (Torrecilla et al., 2015).
However, there was something left: the integration
of an activity in the early stages of ASD where
executing the process of discovering services that
cover the requirements represented by User Stories.
This problem is related to software reusability in
early stages of development of the lifecycle. In light
of this, a process that consisted of five steps was
proposed, as shown below:
§ Indexing the Services Portfolio.
§ Formalizing the Agile requirement (Figure 4).
§ Transforming this formalization into a query.
§ Launching this query against this index.
§ Obtaining the Services that could cover this
Agile requirement.
This is an example of how the use of CBPS
approach could connect Agile requirements
elicitation to other fields of software engineering.
This section will present some limitations and
discussions the proposed model poses in order to
clarify when and how it can be used.
Regarding drawbacks, we have identified a list of
criteria that should be present to define good CBPS.
This is what we have named as “must-have criteria”,
that is to say, their presence or absence conditions
that make the definition of CBPS succeed or fail.
As it has been stated in this paper, our approach
mainly depends on Agile and HCD techniques (by
means of techniques like persona, storyboards and
user stories). Thus, the use of CBPS will require a
HCAD environment, which in turn will demand full
users involvement, as it will clarify notions like
context of use (stakeholders, not only users of the
systems, but also people interested in outputs and
outcomes, can help clarify this context). Finally, our
approach is also conceived in terms of Web
Systems, as it includes elements like navigation
relationships that may not make too much sense in
other type of software development projects.
In addition to “must-have criteria”, we have
identified some other criteria that are very useful to
have, although they are not mandatory to define
successfully CBPS. We have named them as “nice-
to-have criteria”. This latter category includes the
participation of stakeholders. Table 1 summarizes
both “must-have” and “nice-to-have” criteria:
Table 1: Must-have and nice-to-have criteria.
Agile Environment
User involvement
Web System
User interaction with UI
HCD techniques
Involvement of
Even though the model has some limitations,
expressed by the described criteria, we can also
highlight that CBPS might be useful to initially
populate the Product Backlog of a Web Project in
what is known as “Sprint-0” or “Iteration-0”
(Torrecilla-Salinas et al., 2015). In this case, the
Product Backlog might be an ordered list of CBPS.
This way of defining Agile requirements might
allow a systematic definition of roles, user needs and
scenarios of usage (by means of a gathering
personas, user stories and storyboards) without a
significant increase in the overhead of the
development process (in the cost/benefit ratio).
Once the Product Backlog is initially defined, the
technique should be used along “Product Backlog
grooming” sessions (Cohn, 2009), as well. The idea
is that those sessions will review and enrich the
process of gathering personas, storyboards and user
stories, by adding, modifying or deleting elements so
as to keep the Product Backlog always updated.
The main contribution of this paper is the definition
of the concept CBPS. Together with this new
concept, its formalization through a metamodel
allows linking it to different fields of Software
Engineering. A CBPS can be utilized as a way to
formalize Agile requirements in Web projects.
Along this paper, we have shown how user and
stakeholder needs can be modeled by personas as
well as how the context of use can be visualized by
storyboards. These artifacts enable us to create this
new type of user stories in which all the relevant
elements and its interactions have been presented.
Furthermore, we have provided a real life example
of our artifacts related to a Web project in the area of
E-government. Finally, we have discussed the
limitations of our approach, establishing the
different criteria that should be required in order to
successfully apply the technique. Together with the
restrictions identified, we have also pointed out that
the proposed model will need more empirical
validation, which could be fulfilled in future work.
As it can be explained, formalizing an Agile
requirement by means of a CBPS provides an
important link between Agile approaches and other
Software Engineering fields that might benefit from
the HCAD approach proposed in our work.
An example of this link, and also a first future
line of research, is Model-Driven Web Engineering,
which could take advantage of the use of the
presented techniques in order to define formally
requirements in an Agile way, that could lead to the
automatic generation of a “draft Product Backlog” to
be implemented during the development project.
Additionally, as a second future line of research,
this approach can also be useful for those
researchers and practitioners that work on
connecting Agile to maturity models like those of
CMMI family (Torrecilla-Salinas et al., 2016). The
idea of formalizing requirements in an Agile way
without a significant increasing overhead might help
in the process of institutionalizing Agile without
loosing agility.
As a third and last future line of research, the
proposed model might be an initial step in order to
associate Agile requirements engineering with
Human-Centered Design, with the goal of making
Agile Software Development more human-centric.
Finally, it must be stated that the elicitation of
“Agile UI techniques” could be an interesting
research topic derived from our approach.
This research has been supported by the MeGUS
project (TIN2013-46928-C3-3-R), Pololas project
(TIN2016-76956-C3-2-R) and by the SoftPLM
Network (TIN2015-71938-REDT) of the Spanish
Ministry of Economy and Competitiveness.
Anderson, D.J., 2010. Kanban - Successful Evolutionary
Change for your Technology Business, Blue Hole
Beck, K. et al., 2001. Manifesto for Agile Software
Development. 2001.
Accessed April 1, 2016.
Beck, K., 2000. Extreme Programming Explained:
Embrace Change, Boston: Addison-Wesley.
Cohn, M., 2009. Succeeding with Agile Using Scrum,
Boston: Addison-Wesley.
Cohn, M., 2004. User Stories Applied: For Agile Software
Development, Boston: Addison-Wesley.
Cooper, A., 1999. The inmates are running the asylum,
Sams. Indianapolis, USA.
Deshpande, Y., Marugesan, S., Ginige, A., Hanse, S.,
Schawabe, D., Gaedke, M., White, B., 2002. Web
Engineering. Journal of Web Engineering Vol. 1 Nº 1,
pp. 3-17.
Dybå, T., et al., 2008 Empirical Studies of Agile Software
Development: A Systematic Review. Inf. Software
Technology 50 (9-10), 833-859.
Escalona, M.J., Aragón, G., 2008. NDT: A Model-Driven
Approach for Web requirements. IEEE Transactions
on Software Engineering, 34 (3), 370-390.
Escalona, M.J., Koch, N., 2007. Metamodeling the
Requirements of Web Systems. Web Information
System and Technologies, pp. 267280, Springer,
Escalona, M.J., Mejías, M., Torres, J., 2004. Developing
systems with NDT & NDT-Tool. In: Proceeding of
13th International conference on information systems
development: methods and tools, theory and practice,
pp. 149-159. Vilna, Lithuania.
Harbers, M., Detweiler, C., Neerincx, M.A., 2015.
Embedding Stakeholder Values in the Requirements
Engineering Process. In: Proceedings of 21st
International Working Conference, pp. 318-332.
Hu, R., Wang, Z., Hu, J., Xu, J., Xie, J., 2008. Agile Web
Development with Web Framework. In: Proceedings
of 4th International Conference on Wireless
Communications, Networking and Mobile Computing.
IEEE, Dalian, China.
Hudson, W., 2013 User stories don't help users,
Interactions, pp. 50-53.
ISO: ISO 9241-210:2010 - Ergonomics of human-system
interaction - Part 210: Human-centred design for
interactive systems.
Jeffries, R., 2001. Essential XP: Card, Conversation,
onconfirmation/. Accessed April 1, 2016.
Maguire, M., 2013. Using human factors standards to
support user experience and agile design. In:
Proceedings of the International Conference, UAHCI
2013, Held as Part of HCI International 2013. Las
Vegas, USA.
Mendes, E., Mosley, N., 2005. Web Cost Estimation: An
Introduction. Web Engineering: Principles and
Techniques, pp 182-202, IGI Global.
Näkki, P., Koskela, K., Pikkarainen, M., 2011. Practical
model for user-driven innovation in agile software
development. In Proceedings of the 17th International
Conference on Concurrent Enterprising, pp. 1-8.
Poppendieck, M., Poppendieck, T., 2003. Lean Software
Development. An Agile Toolkit, Boston: Addison-
Pressman, R.S., 2000. What a Tangled Web We Weave.
IEEE Software (1-2), pp 18-21.
Pruitt, J., Adlin, T., 2010. The persona lifecycle: keeping
people in mind throughout product design, Morgan
Reifer, D.J., 2000. Web Development: Estimating quick-
to-market software. IEEE Software (1-2), pp. 57-64.
Schön, E.-M., Thomaschewski J., Escalona, M. J., 2017.
Agile Requirements Engineering: A systematic
literature review. Computer Standards & Interfaces
(49). pp. 7991.
Sutherland, J., Schwaber, K., 2011. The Scrum Guide: The
Definitive Guide to Scrum,
Scrum-Guides. Accessed April 1, 2016.
Torrecilla Salinas, C.J., Sedeño, J., Escalona, M.J., Mejías,
M., 2015. Estimating, planning and managing Agile
Web development projects under a value-based
perspective. Information and Software Technology 61,
124144 .
Torrecilla Salinas, C.J., Sedeño, J., Escalona, M.J., Mejías,
M., 2016. Agile, Web Engineering and Capability
Maturity Model Integration: A systematic literature
review. Information and Soft. Technology 71, 92-107.
Truong, K.N., Hayes, G.R., Abowd, G.D.: Storyboarding:
An Empirical Determination of Best Practices and
Effective Guidelines. In: Proceedings of the 6th
Conference on Designing Interactive Systems, pp. 12-
21, New York, USA (2006).
Valderas, P., Pelechano, V., 2011. A Survey of
Requirements Specification in Model-Driven
Development of Web Applications. ACM Trans. Web
5 (2), 10.
Winter, D., Holt, E.M., Thomaschewski, J., 2012. Persona
driven agile development. Build up a vision with
personas, sketches and persona driven user stories. In:
Proceedings of the 7th Conference on Information
Systems and Technologies. Madrid, Spain.
... The persona on the top was used in Software Development domain to introduce a concept of Contextbased Persona Stories (Sedeno et al., 2017). The persona was presented using bullet points and formatted according a particular structure. ...
... We noticed a number of differences in the way such personas were presented, including the way the personas were narrated, the use of visual representations (i.e., a photograph of a real person, a cartoon picture), the format used to present the personas, the (Sedeno et al., 2017); Semi-structured persona (centre) (Ho and Lin, 2019) ; Brief persona (bottom) (Askarbekuly et al., 2021) different human factors presented in the persona descriptions, and the level of detail in different personas. ...
Conference Paper
Personas have been widely used during requirements engineering-related tasks. However, the presentation, composition, level of details and other characteristics varies greatly by domain of use. To better understand these, we formed a curated set of nearly 100 personas from 41 academic papers and analysed their similarities and differences. We then used our analysis to formulate a preliminary taxonomy of personas used for Requirements Engineering-related tasks. We describe our key findings from our analysis with examples, our preliminary taxonomy, and discuss ways the taxonomy can be used and further improved.
... ezScrum since last year was in the phase of architectural transition from the old style of the monolithic to the microservice, this transition is due to the monolithic architecture that currently used by ezScrum is very dependent on specific technologies that have been used more than ten years since the first release ezScrum and the development of some of these technologies have even discontinued. In the implementation of the microservice architecture, large monolithic applications such as ezScrum are split into several modules each of which would become independent service and each service has its own technology coverage with its functionality and clear boundary [1]. ezScrum is a web application that facilitates system development through a scrum framework with several key functions such as product backlog, sprint planning, sprint backlog, taskboard, burndown chart, task management and et cetera. ...
... The first step that needs to be done is to identify the logical architecture of the ezScrum and find out in which cluster that business logic and domain model reside. This process is called isolating the domain [1]. This task including reading and organizing the existing source code and draw it into context diagram which is necessary to get the more profound understanding of the overall business process of ezScrum. ...
The software ezScrum is a legacy web application that has been developed and maintained for more than ten years. With web technology constantly evolving, the ezScrum development team has found it increasingly difficult to keep up and many older technologies are still used. A consequence is the slowdown of release. Examining the issues, we have found the main cause to be the coupling of ezScrum modules since ezScrum is a monolith. Thus, effort has been taken to convert ezScrum into a set of microservices so that coupling is reduced. This thesis reports our work on extracting the product backlog from ezScrum. As demonstrated, the extracted product backlog microservice operates as an independent web application that collaborates with other extracted microservices from ezScrum including account management.
... Modelling agile requirements using context-based persona stories 7 Presenta un método para la modelación de historias de usuario en procesos agiles mediante técnicas HCD (Sedeño et al., 2017). ...
Full-text available
The benefits obtained through the implementation of new technologies are undeniable. From the industrial revolution in the 18th century to the present day, these advances seek at all times to optimise the consumption of resources, raise the quality of the product or service and increase the efficiency of processes. (Sanzana et al., 2022). With this as a premise, we are in the midst of the maturity of Industry 4. 0 which is framed in data management, computer science and telecommunications, and through these, we seek to design a platform that captures and analyses information according to machine learning algorithms, from operational parameters and maintenance routines of industrial air conditioning systems (for this specific case, partial simulation of the data will be performed, including alterations to visualise responses) in order to obtain a machine learning model that allows us to anticipate failures and/or deterioration of the equipment (Es-sakali et al., 2022) Enabling in practice, the pre-staging of resources and spare parts, executing work with the least effect on production. Leaving such metrics to further research (Es-sakali et al., 2022).
... There are various approaches for how to design GUIs, i.e., processes (e.g., HCD process [29]), artifacts (e.g., personas [82]), or guidelines (e.g., the law of proxim-ity [15]). Some of these approaches (e.g., the HCD or personas) can also be applied to VUI design since they address all interactive systems or users in general. ...
Conference Paper
Voice user interfaces (VUI) come in various forms of software or hardware, are controlled by voice, and can help the user in their daily life. Despite VUIs being readily available on smartphones, they have a low adoption rate. This can be attributed to challenges such as the misunderstanding of voice commands as well as privacy and data security concerns. Still, there are intensive VUI users, but they also raise concerns that may be independent of culture. Hence, we will discuss in our paper the various areas that should be considered when developing VUIs to increase user acceptance and foster a positive user experience (UX). We propose exploring the context of use and UX aspects to understand users’ needs while using VUIs. All of our suggestions can help VUI developers to design better VUIs.
... • Quality assurance in initial phases of software development life cycles: The impactful papers were published after the end of millennia. The research was mainly focused on how to assure software quality on the architectural level [51,52] and software requirements [53][54][55]. • Search-based software engineering for defect prediction and classification: The research on this theme has become important in the last 15 years. The research mainly used data mining and machine learning to predict software defects and failures using static codes and other software documents [56][57][58]. ...
Full-text available
Interconnected computers and software systems have become an indispensable part of people’s lives in the period of digital transformation. Consequently, software quality research is becoming more and more critical. There have been multiple attempts to synthesise knowledge gained in software quality research; however, they were focused mainly on single aspects of software quality and did not structure the knowledge holistically. To fill this gap, we harvested software quality publications indexed in the Scopus bibliographic database. We analysed them using synthetic content analysis which is a triangulation of bibliometrics and content analysis. The search resulted in 15,468 publications. The performance bibliometric analysis showed that the production of research publications relating to software quality is currently following an exponential growth trend and that the software quality research community is growing. The most productive country was the United States, followed by China. The synthetic content analysis revealed that the published knowledge could be structured into six themes, the most important being the themes regarding software quality improvement by enhancing software engineering, advanced software testing and improved defect and fault prediction with machine learning and data mining.
Full-text available
Voice user interfaces (VUI) come in various forms of software or hardware, are controlled by voice, and can help the user in their daily life. Despite VUIs being readily available on smartphones, they have a low adoption rate. This can be attributed to challenges such as the misunderstanding of voice commands as well as privacy and data security concerns. Still, there are intensive VUI users, but they also raise concerns that may be independent of culture. Hence, we will discuss in our paper the various areas that should be considered when developing VUIs to increase user acceptance and foster a positive user experience (UX). We propose exploring the context of use and UX aspects to understand users’ needs while using VUIs. All of our suggestions can help VUI developers to design better VUIs.KeywordsVoice User InterfacesVoice AssistantsDesignEvaluationUser Experience
Full-text available
Context: Requirements Engineering (RE) is one of the key stages in software engineering that requires a high involvement of humans (i.e., stake-holders). The aim of RE-related tasks is to develop the scope of the target software products to ensure they will fulfil its stakeholder needs. During the RE process, the developers have to deeply understand the software stakehold-ers including their needs, motivations, and goals. Attaining this information directly from stakeholders requires regular interaction which needs considerable effort. The persona, as a user representation, is a useful tool that can reduce effort amount by modelling the software users and being the primary source of information. Objective: The aim of this work was to systematically review relevant studies that have investigated the use of personas in the RE process, the benefits of personas, and challenges during the implementation of personas in the RE process. Method: A systematic literature review was conducted using a formal protocol based on an established guideline. The systematic search resulted in * Corresponding author a total of 1,501 publications from six databases. After filtering, 75 relevant studies were selected for critical appraisal, analysis, synthesis, and reporting Results: We identified methods to create and validate personas (mostly qualitative), mapped the benefits of using personas in the RE process (to ensure stakeholders' satisfaction, support a human-centric RE process, and support developers' tasks and roles in the RE/SE process), identified methods used with personas, discovered challenges during persona incorporation in the RE process and their respective mitigation strategies, and recommended potential strategies for unaddressed challenges. We also make recommendations for future research directions. Conclusion: The findings of this SLR will help researchers and practitioners better understand the use of personas in the RE process and highlights key research gaps that should be focused on in future research.
This chapter highlights components of web design and evaluation for human factors and ergonomics. Several basic types of websites are commonly encountered: information dissemination, portal, social networking/community, search, e-commerce, company information, and entertainment. Websites should be designed with the end users in mind at all times because the sites should support user activities. Content design and presentation can be decomposed even further into specific components, such as page design, navigation, use of multimedia, search design, and uniform resource locator design. The chapter examines key factors that designers should consider when organizing the content of websites and how to present the information effectively. Successful structuring and organization of the components in a website will lead to more efficient navigation and search of information. A common way to inform users of a website's handling and dissemination of personal privacy information is to post a privacy policy.
Conference Paper
Full-text available
The ISO 9241-210 standard provides a framework for human-centred design (HCD) activities comprising the four stages: context of use, specification of user and organisational requirements, design solutions, and evaluation against requirements. Other parts of the 9241 standard cover user interface design and usability. This paper uses the HCD framework to emphasise user experience (UX) design and methods used to help create good user experiences. It also relates the framework to an agile software development environment. It is concluded that the flexible and iterative nature of ISO 9241-210 makes it a good basis for both user experience design and an agile development process.
Full-text available
Despite the diversity of Web application types, technologies employed, and the number of free templates available on the Web, we still have a considerable amount of Web companies bidding and competing for as many Web projects as they can accommodate. Bidding and winning a proposal does not mean that the project will be developed within time and budget. Cost estimation can help managers manage projects adequately and bid for projects based on realistic and feasible costs and deadlines. The objective of this chapter is to briefly introduce cost estimation principles, followed by a literature review of Web cost estimation. Then we compare this literature according to set criteria.
Nowadays, Agile Software Development (ASD) is used to cope with increasing complexity in system development. Hybrid development models, with the integration of User-Centered Design (UCD), are applied with the aim to deliver competitive products with a suitable User Experience (UX). Therefore, stakeholder and user involvement during Requirements Engineering (RE) are essential in order to establish a collaborative environment with constant feedback loops. The aim of this study is to capture the current state of the art of the literature related to Agile RE with focus on stakeholder and user involvement. In particular, we investigate what approaches exist to involve stakeholder in the process, which methodologies are commonly used to present the user perspective and how requirements management is been carried out. We conduct a Systematic Literature Review (SLR) with an extensive quality assessment of the included studies. We identified 27 relevant papers. After analyzing them in detail, we derive deep insights to the following aspects of Agile RE: stakeholder and user involvement, data gathering, user perspective, integrated methodologies, shared understanding, artifacts, documentation and Non-Functional Requirements (NFR). Agile RE is a complex research field with cross-functional influences. This study will contribute to the software development body of knowledge by assessing the involvement of stakeholder and user in Agile RE, providing methodologies that make ASD more human-centric and giving an overview of requirements management in ASD.
Conference Paper
Software has become an integral part of our daily lives and should therefore account for human values such as trust, autonomy and privacy. Human values have received increased attention in the field of Requirements Engineering over the last few years, but existing work offers no systematic way to use elicited values in requirements engineering and evaluation processes. In earlier work we proposed the Value Story workshop, a domain-independent method that connects value elicitation techniques from the field of Human-Computer Interaction to the identification of user stories, a common requirements specification format in Requirements Engineering. This paper studies whether user stories obtained in a Value Story workshop 1) adequately account for values, and 2) are usable by developers. The results of an empirical evaluation show that values are significantly better incorporated in user stories obtained in a Value Story workshop than through user stories obtained in regular requirements elicitation workshops. The results also show that value-based user stories are deemed valuable to the end-user, but rated less well on their size, estimableness and testability. This paper concludes that the Value Story workshop is a promising method for embedding values in the Requirements Engineering process, but that value-based user stories need to be translated to use cases to make them suitable for planning and organizing implementation activities.
Agile approaches are an alternative for organizations developing software, particularly for those who develop Web applications. Besides, CMMI (Capability Maturity Model Integration) models are well-established approaches focused on assessing the maturity of an organization that develops software. Web Engineering is the field of Software Engineering responsible for analyzing and studying the specific characteristics of the Web. The suitability of an Agile approach to help organizations reach a certain CMMI maturity level in Web environments will be very interesting, as they will be able to keep the ability to quickly react and adapt to changes as long as their development processes get mature.
The processes of estimating, planning and managing are crucial for software development projects, since the results must be related to several business strategies. The broad expansion of the Internet and the global and interconnected economy make Web development projects be often characterized by expressions like delivering as soon as possible, reducing time to market and adapting to undefined requirements. In this kind of environment, traditional methodologies based on predictive techniques sometimes do not offer very satisfactory results. The rise of Agile methodologies and practices has provided some useful tools that, combined with Web Engineering techniques, can help to establish a framework to estimate, manage and plan Web development projects.
User stories are one of the most popular alternatives to traditional user requirement specifications. In most cases, user stories are written about roles that users adopt and take no account of the needs and behaviors of real users. A role is a systemizing concept that has widespread use in business and industry. Its primary function is to describe an individual's activities and responsibilities. user stories can be adapted to be more user-centered by changing their structure and shifting their focus from roles to 'minimal collaborative personas. Each primary persona requires a different user interface. The persona descriptions need to explain what behaviors and needs each persona has that make a different interface necessary. One of the main benefits of persona stories is they and their resulting scenarios and visual designs will be descriptive rather than prescriptive. The core team should be involved in the user research required for personas, at least as observers, and must be actively involved in the development of personas.