Based on what I’ve read, user stories are often cast in a “who”, “what”, and “why” format, i.e. “[Who] wants the system to do [What], so that [Why]”. The “who” and “what” seem easy to grasp. For the example of an ATM:
As a customer
I want to be able to deposit money
The “why” line seems like it could have a significant impact on the scope of the software. For example, all of the following seem like reasonable justifications for the feature; however, the first implies security, insurance, data redundancy, etc…; the second and third imply the existence entirely separate systems; and all three imply data persistence.
So that it will be protected by the bank
So that I can manage my finances online
So that make payments with my debit card
To put it briefly, within the context of agile software development, how are complex/coupled functional requirements handled so that they can be sanely developed?
For example, would the development team derive sets of use cases from such high-level user stories? Or would they re-write the user stories so that they had a limited scope?
I’ve worked in Agile environments for many years. However, one of the things that I’ve always felt uncomfortable about is the idea that each story should map to an end-user request…..i.e., an enhancement that is clearly visible to someone using the application.
However, a significant part of the work in real-life software engineering is done behind-the-scenes and under-the-hood. For example: switching out one ORM or DBMS for another (and the resulting code changes required); or enhancing the performance of the application via implementing more efficient data structures and algorithms; or making the application more scalable/extensible by replacing massive hard-coded
if blocks with a Factory pattern; and so on.
The problem has typically been that, when I would bring these issues up in Sprint planning, product/project managers would throw out the terms “technical debt” and “refactoring” and reiterate that these things should not be the concern of Sprint planning – that instead we need to focus only on user-requested changes.
I admit that a lot of what I mentioned above could be classified as “technical debt”. However, it is my experience that, when something gets classified thusly, it goes into a black hole and is forgotten amidst the never-ending torrent of user requests.
How, then, do we address this? How do we free ourselves of this tyranny? Is there a legitimate way to create stories in Agile that are not centered on things that are immediately visible to end users? And if so, how to we “word” these?
We are planing to setup the process for software development.
We used to follow the proceess of creating the tasks and check with status through scrum call, we call this as agile process. But i really want to understand the process of software development.
We used different tools to manage this process. Suggest me the Best Process to manage team.
I guess there’s no definitive guide, but I’m looking for some book/site that would briefly explain the different methodologies and the main characteristics of agile methodologies. I’d like some introductory text but that on the same time allows me better grasp the concepts behind agile methodologies.
I heard a case where two teams are planning each others’ sprints (estmating stories and deciding what goes into the sprint). The stated benefit is to solve one of the two team’s problem with not finishing their stories within the sprint.
The concept seems strange to me and I’m curious about hearing opinions on this approach and any possible benefits from it?
Our team is developing a project using an Agile development process. All of our requirements are converted into product backlog items and task are broken down based on that. One of my team member suggested to maintain the High Level Document (HLD) and Low Level Document (LLD) for the requirement.
Do we need to have these documents to follow the Agile process?
With the clear roles of Scrum members and the self-management Development team, how to evaluate individual performance?
Who is the person responsible for evaluating and promoting/demoting team members?
What are the processes to collect continuous feedback and build this up to appraisal?
How frequent should the appraisal be performed, after each sprint or annually?
We currently have a maintenance role within our team which the developers on our team rotate each 2 week sprint.
This consists of:
- Responding to user bug reports & creating stories/issues for them
- Responding to negative app store reviews
- Troubleshooting user problems
- Responding to overall user feedback & feature requests
- Fixing urgent defects that were not known at the time of sprint planning
Are all of these tasks within a developers domain or are some of these Product Owner or Scrum master responsibilities?
We recently started using agile methodologies at my company. Because I am quite new to agile, I wonder if our way of implementing it is correct according to the basic principles of agile.
Previously, we had roles such as business analyst, QA tester and software developer. But now management has decided that these roles should be removed and everyone will work as a software developer.
In practice, this means that one software developer will have the same responsibilities as three separate roles previously did (i.e. one business analyst, one QA tester and one software developer).
They justify the change with the fact that this is agile. Is this the way other companies also implement agile?
I’ve been working as a software developer for coming up on 12 years and during this time I have worked as part of a number of successful agile software development teams. Interestingly on most of these teams there was no one fulfilling the role of project manager as the teams in question adhered to the values & principles set out in the Agile Manifesto.
Therefore I have come to realise the following;
If a software development team adheres to the values & principles set out in the Agile Manifesto they do not need someone fulfilling the role of project manager.
My reasons for thinking this are as follows :
- Agile software development teams are cross-functional by nature, which means they consist of software developers and business clients. This adds a high level of transparency to the teams activity, thus negating the role of project manager in relation to tracking and reporting on the team progress.
- Agile software development teams are self-organising, which means the entire team decides on deliverables and associated timelines. In my opinion this removes the need for a project manager in relation to scheduling a teams activity.
- Agile software development teams advocate adaptive planning, which means software developers and business clients can react to shifting requirements. This removes the need for a project manager in relation to scoping estimates for features.
- Agile software development teams encourage rapid and flexible response to change. Therefore having a project manager on an agile software development team would be counter-intuitive as they would add unnecessary process to a lightweight process.
I would be interested to hear the opinion of other software developers on this topic. Do we need project managers on agile software development teams?