Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
We're trying to implement some agile/lean practices in our software development, and one thing I've read is not to maintain a long "wish list", but to keep the product backlog as short as possible with detailed notes only about the things near the top of the list. I can clearly understand the reasoning behind this.
However, often we will have a case where a customer of a tester finds an obscure problem or edge case. We usually do some investigation to find the exact source of the problem so we know how serious it might be (e.g. could it affect other cases?) and often consider how we would solve it and/or what workarounds are available. In some cases we don't go through with the actual fix because we think the cost/benefit isn't worth it at the time, but I still want to record the results of our investigations so that if the problem happens again in future, it's easy to recognize it and see what workarounds we used, and because we might decide that it's worth fixing it after all
At the moment we create a jira ticket with a special category called "wish list" for anything like this. Is there are more "agile" approach we should be using?
Be ruthless with your jira's, there is nothing to be gained by documenting every issue you find. Remember the agile manifesto - "Working software over documentation".
Fix the blockers right away, put the critical ones in the backlog and schedule in the next sprint, for anything that isn't worth fixing, do the investigation (always investigate bugs), write a few quick notes, and close it with the jira status 'wont fix'.
In Jira, or whatever tool you use, it is common Agile practice to close such a ticket with a closure reason of "rejected" or "answered". This will maintain the minimal documentation to prove that the issue was investigated but also communicate that the cost-benefit of pursuing the issue any further was not worth it. This backlogs then should be considered completed in any reporting roll-up and shouldn't distract the team during future backlog grooming or planning sessions.
Related
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 6 years ago.
Improve this question
I'm currently confused in incremental software methodology
what is the main difference between incremental development which adopt plan driven approach and the one that adopt agile approach ?
can anyone explain to me what is the difference between those two and if my choice was good for the project?
Learning is at the core of the agile approaches. It embraces the fact that it is almost impossible to have enough information to make detailed plan up front. Instead implementing, or possibly trying to implement, your first feature will trigger very valuable learnings. Both about your implementation and the usage and actual needs in the field.
I'm not sure what "documentations are really important" actually means, but dividing implementation along module boundaries will cause a number of unwanted effects:
you can only learn about the usage of the complete system after all modules are done, a.k.a. Too late. That will drive unknown remaining amount of work after you thought you were done.
how do you know that the first module is done? Presumably based on some guesswork about what it should do, which might be right but most probably is at least slightly wrong, which causes unknown late modifications
integration problems will also show up after the third module was supposed to be finished
All three drive late realizations about problems and unknown amount of work left to the end.
Agile focuses on driving out these learnings and information by forcing early feedback, such as early integration (as soon as there is a skeleton for the three modules), user feedback by forcing implementation of one user level feature at a time with demos of them as soon as hty are ready.
It is a strategy for minimizing risks in all software endeavours.
In my mind, you should have gone for an agile aproach.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 8 years ago.
Improve this question
My current work involves working on a large number of bugs.
We normally (non TFS) would add these to an iteration backlog (grouped into Stories) after estimating and prioritising; then work through, mark actual effort.
I want to try and understand how I would work on these bugs using the TFS Agile template as intended. But am really struggling to find best practices and examples specifically for bugs for the TFS Agile template in TFS2010.
Cheers, Nick
I hear some parts in your question:
"Add these to an iteration backlog": you can use the iteration path of the work items. Best practice is to create an iteration called backlog.
"Grouped into Stories": In TFS 2010, the default traceablity is that on a User Story you define the Test Cases which validate the User Story. The Bugs are reported against the Test Cases.
"Estimating": You can use the Remaining work field for that
"Prioritsing": You can use the Stack Rank field
"Mark actual effort": Use the Completed work field
What we have been doing is:
Raising bug during testing by a tester.
During iteration planning we may decide to allocate X amount of time to fix outstanding bugs, so we creat a bug fixing story for that iteration of X story points.
Bugs are chosen that we think should be fixed within the iteration, a task is created for each bug along with a time estimate and any high level technical details. Note the task is created as a child of the story and also related to the bug.
The key is that bug work items are not developed against directly, a related task is.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
I'm sorry if this is a duplicate, but the question search terms are pretty generic.
I work at a small(ish) development firm. I say small, but the company is actually a fair size; however, I'm only the second full-time developer, as most past work has been organized around contractors.
I'm in a position to define internal project process and policy- obvious stuff like SCM and unit-testing. Methodology is outside the scope of the document I'm putting together, but I'd really like to push us in a leaner (and maybe even Agile?) direction.
I feel like I have plenty of good practice recommendations, but not enough solid motivation to make my document the spirit guide I'd like it to be. I've separated the document into "principles" and "recommendations". Recommendations have been easy to come up with. Use SCM, strive for 1-step, regularly scheduled builds, unit test first, document as you go... Listing the principles that are supposed to be informing these recommendations, though, has been rough.
I've come up with "tools work for us; we should never work for tools" and a hazy clause aimed at our QA (which has been overly manual) that I'd like to read "tedium is the root of all evil".
I don't want to miss an opportunity with this document to give us a good in-house start and maybe even push us toward Agile. What principles am I missing?
EDIT 4/15 -
I might have been ambiguous about the scope of this document. For now, it's policy that my co-dev and I plan to follow. So far, we've been given free reign on choice of local tool, source control, etc, and the general process we follow in development (eg build, deploy, whether to use continuous integration...).
Ideally, I'd also like this document to be a model on which to base further process improvements. I'm mostly thinking QA, and maybe nudging our project management towards something lighter and iterative.
The Agile Manifesto and its principles might help with a few more ideas
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
My team does some development, but is mainly involved in supprting an existing suite of applications. We now have an imbedded tester (and another on the way). So how can I apply agile practises in what is a purely reactive situation?
You could try to use Kanban. It is more suited for such dynamic situations than Scrum. The ultimate solution would be to use Kanban for support activities and Scrum for development, but in case you spend much less than 50% of your time for development this may be not worthed (overengineering).
Even though it is purely reactive, you surely have larger requests that need to be prioritized? I am using Scrum in a support situation to help prioritizing the non-emergency work that often requires hours or days of effort. I think that Scrum in some ways fits in even better in a support situation than in development.
I would start with prioritizing the issues that come in (someone from the business end should be responsible for that), making things visible (e.g. getting them up on a task board), and improving your definition of done for each task (tests, code review, etc).
Now that you have a tester with the team, it would be a good time to start some TDD and definitely start automating a lot of your tests.
Once you have some of these basics in place, you can look at either Scrum or Kanban depending on your needs. If tasks always seem to come out of the blue, Kanban is probably more appropriate as another poster suggested.
In order to be successful with Kanban, you must make sure that you have a very solid definition of done to ensure that you maintain quality throughout. Without it, you won't see the full benefit.
I would also recommend scheduling regular retrospectives to see what is working for you and where you need to improve.
Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 5 years ago.
Improve this question
Can anyone suggest a set of "commandments" to make everyone operate efficiently during a development project? I am looking for commandments on how Dev and QA and Management should interact. If you lookup Agile or Scrum development models they can explain peoples roles and how things work but it doesn't define a set of bylaws that protect peoples roles from each other.
Micromanagement shouldn't need to occur when rules work properly. QA should have all information they need to test and managment should define what a successful test is. Etc.
If such a set of rules existed and was known to work well, a large industry of consultants would disappear overnight. By the contrapositive, there are no "rules" that meet your qualifications.
All the roles are part of the same team, so everyone share the same goal. People collaborate, meet daily, communicating directly, preferably face-to-face.
Everything is based on trust, there is no need for "protection".
The relationships should all be spelled out pretty well in Agile. Of course, with Agile the point isn't to protect you from each other, it's to eliminate differences between you.
For instance, you are supposed to get rid of the concept of code ownership, if you find broken code you fix it. If you need help, pair with the original author.
QA needs representation in the core team. They don't get left behind because they are in every scrum meeting--as, of course, is the customer.
Management's role (if there is management) in agile is to stay out of the way and provide treats :)
These kind of things weren't just made up for fun, they really are important.
How about the agile manifesto?
http://agilemanifesto.org/
And the 12 priciples, which I'm sure you'll link through to:
http://agilemanifesto.org/principles.html
Edit
Sorry, I misunderstood the question. These are still some good principles!
Just keep communicating and addressing trouble when it comes up.
It's like in marriage: you can't prepare for every contingency beforehand -- you must be willing to deal with every setback that occurs by talking it through with your partners and finding a way to cope with it.