Aucun message portant le libellé Agile. Afficher tous les messages
Aucun message portant le libellé Agile. Afficher tous les messages

25 avril 2011


INVEST in Good Stories, and SMART Tasks

This really interesting article by Bill Wake explains how to write good stories and tasks following the INVEST (Independent, Negotiable, Valuable, Estimable, Small and Testable) and SMART (Specific, Measurable, Achievable, Relevant and Time-boxed) models.

Here is the Youtube video if you prefer :)


20 juillet 2010


Stop starting, start finishing

http://www.slideshare.net/jchyip/stop-starting-and-start-finishing

17 mai 2010


Subordinating the Scrum Team

From http://www.leadingagile.com/2010/05/subordinating-scrum-team.html


Agilists intuitively get that it's a bad idea to build an inventory of detailed specs way ahead of when they are going to get turned into software. Why? Because we know that as our product emerges, we are going to want to make changes to those requirements. There is a real risk that a lot of that work will end up being waste. That's a big part of why we document agile requirements as user stories... we want the placeholder now, but we don't need the details until we get closer to building that part of the product. It keeps our options open and our overhead low.

Building an inventory of requirements has a more insidious impact than just opening up the possibility of waste. Sure, we risk specifying stuff that the business might not need, but we also build in assumptions and risk that can't be validated. Everything that we define now, everything that can't be built and tested immediately after specification, represents something that we'll have to validate or mitigate somewhere down the road. Those uncertainties make it really hard to forecast when we are going to get to done. They make it tough to be predictable.

Furthermore, requirements gathering an analysis shouldn't be done in a vacuum. We know that we're going to want some help from our development team to discuss what's possible from a technology perspective. When we pull our team into meetings to discuss these things, we are taking their attention away from the task at hand. Our team is working on the highest priority features, and here we are pulling them away to help forecast lower priority requirements that may or may not ever make it into the product. It's a pretty solid formula for going slower than we have to.

Even though we may have some capacity to do the requirements work... and it would be nice to get ahead of the game a little... it is not something we generally do on agile projects. Managing all those requirements changes, tracking all those assumptions and risks, and absorbing all the productivity impact to the development team is just too great a cost. We KNOW it is going to cause us problems down the road. Any benefits we'd gain from getting ahead of the requirements work would be lost due to the overhead necessary to maintain our requirements inventory. That inventory slows us down and makes us more resistant to change.

We understand... in this kind of a scenario... that the team has to subordinate the requirements gathering process to the overall production cadence of the delivery team.

Now, let's extend this metaphor up a little and talk about our financial services company... and specifically our new hyper-productive Credit Card Processing Scrum team. With regard to the rest of the organization... our Scrum team is able to produce working software much faster than everyone else around them. The question we're dealing with is... SHOULD they produce working software much faster than everyone else around them? In this context, under this set of circumstances, I'm saying no.

I'm suggesting that the Scrum team in our complex product organization becomes very much like the requirements gathering function in our earlier example.

When the Credit Card Processing team builds software features faster than the rest of the organization can consume those features, they risk the possibility of waste and rework. They introduce assumptions and risks that have to be managed and mitigated throughout the life of the project. They will disrupt the other development teams around them and force those teams to multi-task. The other teams will be forced to pay attention to features that they won't be ready to build for another several months. All that code will slow us down and make us resistant to change.

While it is technically possible for the Credit Card Processing team to get a head of the game... and it might make them feel more productive... it might be great for their team morale... ask yourself what impact they are having on the rest of the organization. It might not be as positive as you think. So... for all the same reasons you might ask a PO or a BA to slow down writing requirements to fill the product backlog, you might want to ask your Scrum team to slow down building software until the rest of the organization can catch up.

It's counter-intuitive, but if you start thinking past the single team, it might be exactly what you need to do.

22 février 2010


10 Things I Hate About Agile Development!

Agile development. Love it or hate it, there's no doubt that it's here to stay. I've enjoyed a great deal of success thanks to agile software development and agile project management methods, but here are 10 things I hate about Agile!

1. Saying you're doing Agile just cos you're doing daily stand-ups. You're not doing agile. There is so much more to agile practices than this! Yet I'm surprised how often I've heard that story. It really is remarkable.

2. Worrying about the difference between 'Agile' (big A) and 'agile' (small a). You mean you spell it with a big A, omg you're so not cool! The differentiation is between Agile methods and being 'agile', in the true sense of the word. Most people probably don't get the subtlety. When people split hairs about this it gets on my nerves and makes so-called agilists sound like a bunch of overly-religious nerds.

3. Thinking that agile is a silver bullet and will solve all your problems. That's so naiive, of course it won't! Humans and software are a complex mix with any methodology, let alone with an added dose of organisational complexity. Agile development will probably help with many things, but it still requires a great deal of skill and there is no magic button.

4. Claiming to be Agile when you're clearly not 'agile'. Yes, we're doing all the major agile practices, but we're not flexible and we don't seem to understand the underlying agile principles. Were agile in practice but don't demonstrate the values of openness, attention to quality, collaboration, team spirit, etc.

5. People who are anti-agile but with nothing constructive to say about why. I hate that. I've had a few turn up here and enlighten us all with their intellectual comments, such as 'snake oil' or 'agile is a hoax'. Losers!

6. Blaming agile - 'I tried it once and didn't like it'. Projects are difficult. Some projects may even fail, even if you are using agile project management methods. As I said earlier, agile is not a silver bullet. It's important not to blame agile when things go wrong, just as it's important not to claim it's the saviour for all of your ills. Don't blame the process. It's a bit like bad workmen blaming their tools. It's not big and it's not clever!

7. Using agile as an excuse - 'no we can't do that, cos it's not Agile'. 'No I'm sorry, we don't do it that way here'. Following the agile process without fail regardless of the circumstances - even if it's contrary to what the situation really requires for the business or for the customer. If the process is the most important thing, above all else, that's not agile!

8. People who think they're smart enough to adapt agile processes before they've really got enough experience to understand how and *why* it works. It's an easy trap to fall into, but one that should be resisted. Otherwise it's so easy to throw the baby out with the bathwater!

9. People who use agile as an excuse for having no process or producing no documentation. If documents are required or useful, there's no reason why an agile development team shouldn't produce them. Just not all up-front; do it as required to support each feature or iteration. JFDI (Just F'ing Do It) is not agile!

10. People who know more about agile development than me. They're so smug ;-)

Ah, that's better! I feel much better now I've got that off my chest.

Thank you for listening!

Kelly.

P.S. - one more thing! I hate people who rant about agile development on agile blogs. That's just silly.

Picture by beneneuman

20 février 2010


Agile Game Development : Agile Game Development Checklists

The Agile Game Development Checklists are meant to help drive discussion about the implementation and effectiveness of agile practices (including Scrum, XP, TDD and Kanban) for a team and stakeholders.

This first version contains a checklist for the ScrumMaster role. Revisit how this role adds value to a Scrum Team and how that role can be improved.
read more

4 janvier 2010


Reduce Manual Test Technical Debt

When a team that has relied mostly or entirely on manual testing decides to adopt Scrum, it will quickly discover how hard it is to run short sprints when there’s a lot of manual testing to be done each sprint. It will also realize that unless it does something drastic, the technical debt will continue to accumulate. Teams in this situation can follow a three-step process to extricate themselves from at least the worst of these problems:
  1. Stop the bleeding.
  2. Stay current.
  3. Catch up.
The first priority of a team with technical debt in the form of an over-reliance on manual testing is to stop the bleeding, stop things from getting worse. The best tourniquet is to find ways to automate some of what is being tested manually. To mix metaphors, teams should find the low-hanging fruit: tests that will be easy to automate but save a lot of manual effort. Brian Marick, a leading authority on testing and coauthor of the Agile Manifesto, has told me that “the real low-hanging fruit is often not automating some test execution but automating other testing tasks, like populating databases or automatic navigation to the page where you’ll start manual testing. You’re not reducing the number of manual tests, but you’re reducing the total time it takes to run them.”
After the bleeding has been stopped, the situation will no longer be getting worse from sprint to sprint. Manual tests still will be added each sprint but the team is finding enough low-hanging fruit each sprint to offset the time needed to run the new manual tests. At this point, it is time to move to step two: learning to stay current. During this phase, the team focuses on learning how to write and automate tests for whatever new features are added during the sprint. While doing this, no more debt is accumulating, so the situation isn’t getting any worse, but it’s not yet getting any better either. Learning to add automated tests in the same sprint as the feature will be a new skill for the team. It won’t be as hard to learn as the initial skills were during the first phase but will require new discipline.
Eventually the team enters the final phase, which is when it catches up on additional outstanding testing debt. I generally tell teams that I coach that I don’t care how quickly the outstanding testing debt is brought down as long as it is indeed coming down. Obviously, I would prefer the debt to come down as fast as possible. But, by stating it this way I am emphasizing that what I am most concerned with are the first two steps: stop the bleeding and stay current.
For more on testing with an agile process like Scrum, pick up a copy of Succeeding with Agile.


From http://blog.mountaingoatsoftware.com/reduce-manual-test-techcnical-debt

30 novembre 2009


Metrics in an Agile World

http://www.infoq.com/presentations/agile-metrics

18 novembre 2009


Kanban Kick Start

12 novembre 2009


Lean-Agile Software Development: Achieving Enterprise Agility



http://www.netobjectives.com/resources/books/lean-agile-software-development

26 octobre 2009


Are you a good Scrum master ?

crum master is a servants leader .. We say this all the time.. So Scrum masters .. how good you rate yourself as a leader is scrum project. check out this matrix introduced by Bob Hartman (Agile Bob)




1. Listening – actively listening to what others are saying
2. Empathy – feeling the pain and thrills of others
3. Healing – helping others after they have been hurt
4. Awareness – understanding the big picture
5. Persuasion – persuading others to do what is right
6. Conceptualization – helping the team understand
7. Foresight – seeing problems before they arise
8. Stewardship – helping the team use resources most effectively
9. Commitment to growth of others – helping others improve
10. Building community – helping the team become more than a
group of individuals


From http://projectized.blogspot.com/2009/10/are-you-good-scrum-master.html

11 octobre 2009


Scrum doesn’t do anything

Brilliant post!


“Doing Scrum” is as meaningless (and impossible) as creating an instance of an abstract class.  Scrum is a framework for surfacing organizational dysfunction.  It is not a process and it is not prescriptive.  The core framework of Scrum, as described (e.g.) here and here does not actually do anything.  It is, in a sense a contract we put in place between those seeking value and those building it.  But a contract doesn’t produce anything.  An interface is passive.  We need an implementation.
Scrum begins to work when people understand it well enough to create a concrete implementation, to emerge a process that is their own.  Understanding and respecting the Scrum framework and the set of rules allows you to become aligned with others, to have a common set of values and principles from which to operate.
Scrum itself can be thought of as similar to a set of game rules.  Think chess, think soccer.  The rules are easy to learn, and knowing them means you can play the game with others.  The rules are the ties that bind us together.  But just knowing the rules means nothing in terms of deriving pleasure from the game.  You need to play, to be involved.  It is doing, not knowing that brings about results.  To play well you need to develop strategy, and in team games you need to develop relationships, and trustful interactions.
In any game, once you start breaking the rules everything falls apart, and no one will want to play with you.  It is the same with Scrum.
So respecting the contract, the rules, or in software parlance, respecting the interface, allows you to create a process that suits your context — and your context is many things… people, industry, business, market place, product, location, language, physical environment, culture, people.  It starts and ends with people.  Scrum doesn’t actually do anything, people do things.  The Scrum process will emerge through the interaction of the people, and it will be different for each organization or team.  And this is where people trip up; too many think that creating their own process starts with breaking the rules.  It doesn’t.  Do that, and you have failed before you begin.
The Scrum process being created must operate within the agreed parameters, must be bounded by the rules.  All methods of the abstract class must be implemented, or the class won’t compile, won’t run.  Try to move your bishop in a straight line in a game of chess, and your opponent will leave the table.  Pick up the soccer ball and throw it and you’ll be red carded.
The framework of Scrum is a powerful mechanism for surfacing organizational and personal dysfunction.  It is that very power that causes people to try to circumnavigate the rules, to take shortcuts.  They don’t want to look.  But not looking doesn’t cause problems to go away or broken things to mend, it just delays the inevitable giant crash.  We don’t call out the value of courage in Scrum for nothing.
Comparing Scrum then to implementation practices such as XP or software craftsmanship makes little sense.  Each of these movements offers excellent tools for implementing a solid Scrum practice, for making the abstract concrete.  Scrum offers a strong framework and a relentless rhythm to shake out the dust of years.
You cannot “do Scrum” but you can certainly embrace it, and the more courageously you do so the stronger will be your emergent process.

From http://agileanarchy.wordpress.com/2009/10/11/scrum-doesnt-do-anything/

What is Agile?

1 octobre 2009


Sondage: Quel est le meilleur outil de gestion de projet Agile?

Le blog "Agile Software Development Made Easy!" effectue un sondage pour déterminer quel est le meilleur outil de gestion de projet Agile.

16 septembre 2009


The Problem With Planning

Agile Software Development Made Easy!  The Problem With Planning.Hi, this is Kelly, from Agile Software Development Made Easy!

I think I've been pretty successful in my career. But if I was better at planning, I wouldn't have achieved half the things I've achieved in my career! In fact, I wouldn't even have started some of them...


In reality, there are some things you can plan, and some things you can't. The trouble is, in most organisations we've come to expect a plan. And to meet it whatever happens. And that's just not realistic.
<!--break-->

Doing detailed planning pre-supposes you know where you want to go and aren't going to be influenced too much by what happens in the meantime - or at least not without a substantial amount of re-planning. This, at least in my experience, has a tendency to give project managers tunnel vision at times.

Now don't get me wrong - I'm not suggesting for one moment you embark on a project that doesn't have a clear and robust vision. And I'm not suggesting for a moment you embark on a project where you have no idea how to achieve it and whether it's a reasonable (although hopefully challenging) goal with the available resources. And forming that into an outline plan to provide some markers to aim for is certainly a good idea, but ideally it's a high level roadmap rather than a detailed plan.

Coming from a traditional software development environment, I realise this sounds slightly mad. And I must admit it takes a certain amount of maturity and experience to recognise that you can't really plan in detail up-front if you want to retain any flexibility, as the real requirements, risks, issues, priorities and opportunities all tend to emerge when you start to build and see the software in action.

Most organisations are not be ready to accept such a radical idea - the idea of acknowledging you don't really know what you want - certainly not for sure - and you don't really know what you're going to get for your money, or when. So, as a minimum, a clear vision and outline plan are essential, but be careful to keep them to a high level.

Rather than a detailed plan, I prefer to see a strong vision, a strategy, goals, and a roadmap (high level outline plan). The tactics to achieve this, for example the precise features and all the tasks to deliver them, can vary along the way and are best not articulated up-front. This enables the team to discover the details when they are in a better position to do so, and allows them to change direction rapidly in response to changing circumstances.

This, when you think of it, is the very meaning of agile...

Kelly.


Photo by tanakawho

9 septembre 2009


Golden rules for software testing


Read these simple golden rules for software testing. They are based on my testing experiences.

Its all about finding the bug as early as possible:
  • Start the software testing process by analysing requirements long before development.
Make sure you have these 3 software testing levels
  • Integration testing (performed by IT)
  • System testing (performed by professional testers)
  • Acceptance testing (performed by business users)
Don’t expect too much of automated testing:
  • First let me state this : automated testing can be extremely useful and can be a real time saver. But it can also turn out to be a very expensive and invalid solution.
Deal with resistance:
  • If you like to be instant popular, don’t become a software tester ! You 'll find out that you are going to meet a great deal of resistance... It is very likely that you will end up being the sole defender of quality at a certain point. Other participants in the project will be tempted to go for the deadline, whatever the quality of the application is.
  • You should deal with this by reporting facts and figures in stead of opinions. It might take a while before your work colleagues appreciate the great job you're doing !
Do regression testing every new release
  • Okay, you've tested your new development successfully. Great. But do the features of the application that you didn't change still work ? You really should test this before going live.
Let real users test with real data
  • This one is obvious but who does it ?
  • You cannot beat real data.
Give defects a test severity status :
  • Critical (must have, no work around)
  • High (must have, work around possible)
  • Medium (not business critical, but wanted)
  • Low (nice to have)
Let product owners deceide if a defect is to be fixed based on business priority:
  • A bit obvious, but I've seen testers make this decision and assign business statuses
  • Actively use these statuses for reporting and follow up !
This might be the most difficult goal to achieve:
  • You should talk about exit and entry criteria with IT. When is software good enough to deliver to a test team ? Think about server errors, certain level of IT testing achieved, when and how to build...
  • Same goes for business. What quality do they expect ? Who is going to make decisions on when to go live ? Make sure it is not you. Your role should be advisory.
Focus on the software testing process, not on the tools:
  • There 's a lot of talking about test management software. Sure, they can be very helpful indeed. These tools probably will take a lot of work out of your hands... But don't forget : it 's you who has to define the testing process. No tool is going to do that for you ! Think thoroughly about how you 're going to organise your testing. You can be very successful by using basic tools like MS Excel.



From http://www.testertroubles.com/2009/05/golden-rules-for-software-testing.html

8 septembre 2009


So, You Want to be a Software Programming Rock Star?


A great Google Tech Talk by Joshua Kerievsky, where he discusses some of the challenges faced by programmers, common gotchas and how Industrial Logic ’s eLearning albums can help you to improve your Programming Skills.
Some of the following topics:
  • What are ‘code smells’ i.e. bad design
  • How do you improve the design of existing code (java, C++, C#)
  • How do you write good unit tests?
  • Test Driven Development
  • How do you deal effectively with legacy code?
  • Design Patterns
ABSTRACT
Presented by Joshua Kerievsky.
Software programming rock stars test-drive their code, refactor mercilessly and deftly apply design patterns.
If youd like to get from musician to rock star status, a good place to start is Industrial Logics eLearning albums. Crafted over the past 4 years, these interactive, multimedia tracks feature challenging labs that rank your level and suggest improvements, engaging videos by experts, stimulating quizzes and an ability to ask questions and receive answers by knowledgeable practitioners.
Join Joshua Kerievsky, founder of Industrial Logic, as he guides you through his company’s state-of-the-art eLearning albums on timeless software design skills.

Agile Project Management – Self-Organisation: The Secret Sauce for Improving your Scrum Team


A ‘must watch’ Google Tech Talk by Jeff Sutherland, one of the founders of Scrum, about the ’secret’ ways to achieve ‘hyper-productivity’ in an Agile Project Mangement environment.
In this seminar, Jeff talks about the following topics:
  • Introduction to the ‘Scrum But…’ (!)
  • How to monetise improved team performance
  • Shock therapy as a strategy for booting up teams.
  • The Cosmic Stopping Problem, otherwise known as the choice uncertainty principle.
  • Punctuated equilibrium – how software systems evolve
Google Tech Talks
September 4, 2008
ABSTRACT
High performance depends on the self-organizing capability of teams. Understanding how this works and how to avoid destroying self-organization is a challenge. Until you understand complex adaptive systems and how Toyota works it is difficult to improve team velocity.
Jeff will discuss three core topics:
  1. Shock therapy as a strategy for booting up teams.
  2. The Cosmic Stopping Problem, otherwise known as the choice uncertainty principle.
  3. Punctuated equilibrium – how software systems evolve
Take advantage of these concepts and you may find a way to achieve the ultimate potential of a team. This session will be a “Deep Agile” presentation keying off topics presented to engineers at MIT.
Speaker: Jeff Sutherland
Dr. Jeff Sutherland is one of the co-creators of the Scrum software development process. He and Ken Schwaber invented Scrum in 1993. Since then he has worked with many software companies and IT organizations to extend and enhance this process.

The Difference Between Waterfall, Iterative Waterfall, Scrum and Lean Software Development (In Pictures!)


Here’s a VERY simple overview of the main differences between Waterfall Development, Iterative Waterfall Development, Scrum/Agile Development and Lean.

Waterfall Development

‘Waterfall Development’ is another name for the more traditional approach to software development.
It’s called ‘waterfall’ as this type of development is often planned using a Gantt chart – you complete one phase (e.g. planning) before moving on to the next phase (e.g. development).
In Waterfall approaches, you will rarely aim to re-visit a ‘phase’ once it’s completed. As such, you better get whatever you’re doing right the first time!
This approach is highly risky, often more costly and generally less efficient than more Agile approaches.
The main issues with this approach include:
  • You don’t realise any value until the end of the project (when you deploy) (See: Self-Funding Projects, a Benefit of Agile Software Development)
  • You leave the testing until the end, which means you’re leaving issue discovery until late in the day
  • You don’t seek approval from the stakeholders until late in the day – their requirements might have changed
  • You’re heavily reliant upon a plan, which you can/will often follow to the detriment of the end result
  • You’re heavily reliant upon a project manager driving the way – the power of one

Iterative Waterfall Development

This approach carries less risk than a traditional Waterfall approach but is still far more risky and less efficient than a more Agile approaches.
The focus is on delivering a sprint of work as opposed to a series of valuable/shippable features.
The most commonly occurring issue in this type of scenario (in my experience) is bottle necking.
For example, you deliver loads of code a little bit behind schedule (?) and you leave it until the last minute to test everything. One issue takes longer than expected to resolve, you miss your sprint deadline and you deliver nothing.
Another common symptom of this type of approach is over-commitment.  It’s really difficult to estimate the totaleffort associated with a particular User Story/Feature when approaching delivery in this phased way. 
You’re more or less forced to estimate each phase separately (e.g. estimate development separately to testing in this instance) – this doesn’t work as the phases are not separate, they’re totally intertwined.
For example, if you find an issue with the test, you must return to development. The whole team must remain focused on delivering the end goal, not the separate phases.
It’s also worth noting that velocity and burn downs are far less (if at all) useful in this type of environment – you don’t benefit from early-warning-signs as you don’t find out whether you’re on track until the end of the sprint.

Scrum Development

This approach carries far less risk than Waterfall approaches.
We focus on delivering fully-tested, independent, valuable, small features. As such, we diversify our risk – if one feature goes wrong, it should not impact another feature.
With that said, we still plan our work in iterations and we will still release at the end of each iteration.

Lean Development

Lean is very similar to Scrum in the sense that we focus on features as opposed to groups of features – however Lean takes this one step further again.
In Lean Development, you select, plan develop, test and deploy one feature (in its simplest form) before you select, plan, develop, test and deploy the next feature. By doing this, you further isolate risk to a feature-level.
In these environments, you aim to eliminate ‘waste’ wherever possible – you therefore do nothing until you know it’s necessary or relevant.
the-difference-between-waterfall-iterative-waterfall-scrum-and-lean

4 septembre 2009


What does ‘Done’ mean in Agile Software Development?


what-does-done-mean-for-an-agile-software-development-team
In Agile Software Development environments, we aim to deliver ‘[potentially] shippable code’ at the end of each iteration.
In actual fact, we often settle for delivering a chunk of value at the end of each iteration.  This ‘value’ may or may not be directly attached to a piece of shippable code. 
We also aim to close each iteration with no leftovers, no dependencies – everything must be ‘done’.
I recently watched a Google Tech Talk by Jeff Sutherland where he discusses ‘Done’ (Scrum Tuning: Lessons Learned at Google). 
Jeff explained that ‘Done’ at Patient Keeper, his company, is a piece of code live to the public having received no complaints within an hour of release.  
This got me thinking.
  • So, what is ’Done’?… 
  • Does ‘Done’ HAVE to be ‘live with no complaints within an hour of release’?…
  • Does ‘Done’ HAVE to be potentially shippable code?
  • What does ‘potentially shippable’ mean?
  • Does ‘Done’ HAVE to relate to the delivery of code?
  • Can ‘Done’ change one a case by case basis? …
In traditional, Waterfall, environments, we follow a series of consecutive steps running between project inception and completion – we understand that we are ‘done’ when all of the steps are complete, the product is released, we disassemble the project team etc.  This is a relatively simple concept to get your head around.
In an Agile environment, however,  we follow these steps each iteration… in fact, we probably follow these steps a number of times per day.
Of course we’re interested in being ‘done’ with the project, but we’re more interested in being ‘done’ with each task, each story and ultimately each deliverable that will in turn deliver value.
So, now we need to define ‘value’! Is value *only* delivered by shipped code? Probably not.
For example, the objective of a Spike is to get a clear idea on where to go next.  ‘Done’ in this situation might be a working prototype that might end up being released – if you’re lucky.
On the other hand, the task(s) could be to deliver a series of findings that inform a decision - ‘Done’ might be a firm decision one way or another e.g. completion of the Planning and Analysis stages.. (see inset image)
As mentioned above, you may decide not to release at the end of each iteration. You may schedule releases around Minimum Marketable Features or Epics that span multiple sprints. In these cases ‘Done’ may relate to the delivery of ‘potentially shippable’ code, which has been fully-tested, acceptance tested and performance optimised (as much as possible).
So, it becomes clear that the definition of ‘Done’ may indeed neeed to vary on a case by case basis.
With that said, regardless of what your definition of ‘Done’ is, the definition must be understood by everyone involved.
From http://agile101.net/2009/09/04/what-does-done-mean-in-agile-software-development

3 septembre 2009


Principles behind the Waterfall Manifesto

If you want to keep your job, we strongly recommend that you follow these principles:

Your highest priority is to take no initiative for which you could be blamed. Taking no initiative at all would be even better.

Changing requirements are a pain in the ass, moreover late in development. Let it know to the customer and make him pay dearly for just thinking about change.

Do not deliver working software frequently, because this could make the customer change his mind (see above).

Business people and developers must work together as fewer times as possible throughout the project. They both have other important activities to carry to waste their precious time in meetings. Furthermore, they do not speak the same language.

Build projects around solid processes because you know that individuals are even more unreliable than software (and you know what you are talking about).

The safer method of conveying information to and within a development team is by a formal document approved by the steering committee.

Project reports and billable hours are the primary measure of progress.

Good processes promote heroes. The sponsors, developers, and users should be able to recognize that they face a difficult challenge.

Recognition of technical excellence and good design allows developers to think that they are free creative artists (and does not burden the project budget).

Complexity - the art of maximizing the amount of time needed to understand your design and code - is essential to define your value as a developer ( and to protect your job).

The best architectures, requirements and designs emerge from nowhere and should be send back there as soon as you detect them. Maintenance and evolution is where money is earned!

At regular intervals, the team should meet to eat pizzas and drink beer. It helps developers to forget that they are working in a bloody software development project and confirms that the management really cares about people. (they do not mention pizzas and beers in the other manifesto, think about it...)