User stories are written throughout the agile project. Usually a story-writing workshop is held near the start of the agile project. Everyone on the team participates with the goal of creating a product backlog that fully describes the functionality to be added over the course of the project or a three- to six-month release cycle within it.
Some of these agile user stories will undoubtedly be epics. Epics will later be decomposed into smaller stories that fit more readily into a single iteration. Additionally, new stories can be written and added to the product backlog at any time and by anyone.
Agile Product Management: User Stories: How To Capture, And Manage Requirements For Agile Product M
Because an epic is generally too large for an agile team to complete in one iteration, it is split into multiple smaller user stories before it is worked on. The epic above could be split into dozens (or possibly hundreds), including these two example user stories:
Whether or not a team is adhering to a certain agile practice (and which one), can further muddy the waters when it comes to what a product manager does. For instance, if a team is practicing scrum, then they also need to have a product owner.
A common challenge with writing user stories is how to handle a product's non-functional requirements. These are requirements that are not about specific functionality ("As a user of a word processor, I want to insert a table into my document."), but are rather about an attribute or characteristic of the system. Examples include reliability, availability, portability, scalability, usability, maintainability. As you can see from that list, non-functional requirements are often referred to as "-ilities." Of course, not all non-functional requirements end in "-ility." We also have security, performance, robustness and so on.
Thinking back into the dark ages, I can remember when I first read about "non-functional requirements." The term threw me for a loop. If it's non-functional, why do I care about it? I'm sure the author of that book clarified this for me a page later, but the term has always seemed an odd one to me. I prefer to think of non-functional requirements as "constraints" we put on the system. When a product owner says, "this system must perform adequately with 100,000 concurrent users," the product owner is putting a constraint on the development team.
The product owner is effectively saying, "Develop this software any way you'd like as long as you achieve 100,000 concurrent users." Each constraint we put on a system narrows the design choices a bit; calling these "constraints" rather than "non-functional requirements" helps us remember this. Fortunately constraints/non-functional requirements can be easily handled as user stories. Here are a couple of examples:
Part of the confusion is that the product owner role is relatively new. It originated as part of the Scrum agile framework in software development, which has been around only a couple of decades. As Scrum and agile became more popular, businesses in industries other than software began to adopt the framework, creating jobs for product owners.
When we stated above that product owners manage the backlog, we did not mean they simply moved existing user stories and other task-level details around the backlog. Product owners must be more proactive than that. In many cases, they are responsible for drafting (or at least refining) these stories into tasks that the development team can execute on.
In a large organization, informal communication and simple backlogs are not sufficient for the management of requirements and development work. Many large organizations are struggling to successfully adopt agile methods, but there is still little scientific knowledge on requirements management in large-scale agile development organizations. We present an in-depth study of an Ericsson telecommunications node development organization which employs a large scale agile method to develop telecommunications system software. We describe how the requirements flow from strategy to release, and related benefits and problems. Data was collected by 43 interviews, which were analyzed qualitatively. The requirements management was done in three different processes, each of which had a different process model, purpose and planning horizon. The release project management process was plan-driven, feature development process was continuous and implementation management process was agile. The perceived benefits included reduced development lead time, increased flexibility, increased planning efficiency, increased developer motivation and improved communication effectiveness. The recognized problems included difficulties in balancing planning effort, overcommitment, insufficient understanding of the development team autonomy, defining the product owner role, balancing team specialization, organizing system-level work and growing technical debt. The study indicates that agile development methods can be successfully employed in organizations where the higher level planning processes are not agile. Combining agile methods with a flexible feature development process can bring many benefits, but large-scale software development seems to require specialist roles and significant coordination effort.
The traditional, plan-driven product and project management models are not well suited for agile development organizations where scoping decisions must be made frequently and requirements engineering is performed concurrently with implementation (Jantunen et al. 2011). If the requirements management processes do not support the agile development organization, it is difficult for the development organization to work efficiently towards the high level goals of the company. Due to the short history of agile methods use in large organizations, reports on the best practices of agile development in large organizations are lacking and many large organizations are struggling to implement efficient requirements processes (Laanti et al. 2011; Wiklund et al. 2013; Cao et al. 2004). Although there is an increasing number of empirical studies of large-scale agile development (e.g., Korhonen 2013; Laanti et al. 2011; Heikkilä et al. 2015b; Moe et al. 2014; Bass 2015; Eckstein 2014), there is little research on requirements management in large-scale agile development organizations (Heikkilä et al. 2015a; Inayat et al. 2015). Furthermore, most of the existing empirical research has focused on method proposal and evaluation instead of understanding the phenomenon (Heikkilä et al. 2015a). Subsequently, more research is warranted in order to identify the contextual factors that affect the success or failure of specific ways of requirements management in large organizations that employ agile development methods. Moreover, requirements engineering activities are complex and intertwined with other development and management processes in the organization (Damian and Chisan 2006), equally affected by human, organizational and political aspects that surround them (Maiden 2012). Furthermore, detailed information on requirements engineering practice in large organizations, in general, is scarce (Maiden 2012).
Our goal is to describe the requirements processes on the release and implementation management levels, and the interactions between the levels in a large organization that develops telecommunications network software and uses agile practices in its software development. We aim to reach this goal by studying the case organization and answering the following research questions:
The main contribution of this research is the in-depth description of these management processes in the case organization. The existing literature on requirements engineering in agile development is largely based on the single-team, single customer context (Heikkilä et al. 2015a; Inayat et al. 2015). To the best of our knowledge, our work is among the first to uncover requirements engineering practices as embedded through the feature development as well as the release project management and implementation management processes of a large-scale agile development organization. Those aspects of large-scale agile development that are not directly related to requirements management are out of the scope of our research. These include, but are not limited to, communication tools, coaching, continuous improvement, agile culture and agile contracts.
In this section, we review related work in order to position our research in the field of requirements management and software engineering research. We also present background information that is beneficial for understanding our case study and its relation to previous research. First, we summarize two recent secondary studies on agile requirements engineering. Second, we discuss research on organizing and managing large-scale agile development. Third, we review three models proposed for scaling agile development in order to provide a point of comparison to our case.
There is no universally accepted definition of agile requirements engineering (agile RE) (Heikkilä et al. 2015a). Inayat et al. (2015) identified the following 17 RE practices that were adopted in agile software development: Face-to-face communication between the agile team members and client representatives, customer involvement and interaction, user stories as specifications of the customer requirements, iterative requirements that emerge over time, iterative requirements prioritization, challenge management, cross-functional teams, prototyping, test-driven development, requirements modeling, requirements management with a product backlog, review meetings and acceptance tests, code refactoring, shared conceptualizations, retrospectives, continuous planning and pairing for requirements analysis. According to Heikkilä et al. (2015a), the activities performed in agile and traditional RE have similar goals, but the methods and emphases are different, since traditional RE emphasizes processes and documents while agile RE emphasizes reactivity and informal communication. 2ff7e9595c
Comments