Agile in small bites: most bumps per dollar

Question

What single aspect of agile development should we implement first of all to improve the development process and why?

I am in a situation requiring me to “tune” my process, rather than to process it, and “moving” seems to be the mantra of the day. If we can make only one change that will improve something - quality, time to market, documentation, transparency, etc., What will have the most noticeable, positive impact?

If we choose correctly, we can make a second choice. :-)

Update: What is your current SDLC?
Environment: essentially "reboot". A small part of the developers; obsolete products with 10 ^ 5-10 ^ 6 VOCs and tens of thousands deployed worldwide; products are highly interdependent; significant functions added over the years, including many one-time ones, without refactoring; hard schedules; superficial OK; there are no posthumous or "process gurus."

Typical process:

• Create a design / specification. Overview of all stakeholders.
• Enter one or more items / fixes.
• Revise design / specification to account for surprises.
• Testing functions, recording defects.
• Priority new and remaining tasks.
• Review design / specification / schedule.
• Return to step 2 if necessary.
• Beta release, record reviews.
• Return to step 2 if necessary.
• Official version.

Thanks for so many helpful tips and ideas!

Answer 1

I am a big fan of mix-and-match and a gradual change in the development process. I agree that iterative development should be your first goal, but I think you can get closer to it with even smaller steps.

In my experience, I would recommend the following order: choose the first one you are not doing yet:

• First fix the errors. I wish I didn’t say that. This is a sanity call, and shorter cycles are also required.

• Small steps. Train the habit of introducing the smallest change, which is a visible step to the next function, then compile and test. Before you start coding, discard all your tasks for 1 hour units. Set up a function code at least every 15 minutes. This does not require a significant change in infrastructure - with the possible exception of the fix for incremental builds and the availability of fast machines.

Yes! Start with the fact that developers have fast cars. How much better is getting advice ?!

• Build everything daily. Configure double-clicking on the complete lines from Source Control on the installation media, ideally on a separate PC. This is the first step to frequent assemblies, but they already help a lot. For us, this was an important step in obtaining reliable, reproducible assembly results.

• Start writing unit tests. Do not worry about coverage, do not use “write tests first”, but put the frames in place. Write tests for new code and changes. Then run them with daily builds.

• Short cycles. Now the time has come, you have all the tools for releasing weekly or two-week releases in homes: The code base is in the delivery state many times a day, which makes the assembly double-click, and at least something works,

Answer 2

Iterative building

When we moved on to creating on an ongoing basis (in our case, weekly or twice a week), we saw the biggest improvement.

When each assembly was completed, we sat down with the development team, the QA team and the product management team and created a list of works that were included in the new assembly.

Then everyone helped answer the question of what should be included in the next assembly.

Since then, we have added many other Agile development capabilities (including trying to implement a scramble with a letter), but nothing has given us as much “bang for the buck” as an iterative building.

Answer 3

Iterative development. Work with small iterations (say, 2 weeks), there is a "ready-made" application at the end of each and only iteration, i.e. Your testers should be happy to publish the results for your customers.

This is the core. You can use this.

Answer 4

See the Best Specific “Operation Guide” in the “ALARM AND / OR AGRICULTURAL DEVELOPMENT MANAGEMENT” section .

My recommendation starts with TDD first. It is very easy to do and has a profound effect on quality.

There are several parts to this.

• Everyone should get the tools (JUnit or something else - this can be difficult in some cultures.)

• Managers must require that testing be completed. They should never (NEVER) circumvent device testing. As soon as someone says that “these tests do not matter, send it anyway”, you canceled all the good from TDD.

• You need to control the test scenario: how much is written, how much has passed. You must define functionality using test cases: the [X] function has [n] test cases, some of which are running, some of which are in process.

Answer 5

Create a cross-functional team with programmers, testers, technical writers, and possibly people working with sales / services. Make them understand the concept of "done", that is, something ready-made is what is written, verified, documented, installed, deployed and ready for use by the client.

This is important because unless all of the different functional areas come together and focus on the sole goal of getting something for the client, you cannot implement any other aspect of the Agile platform.

Answer 6

Agile is a pretty buzzword, but please keep in mind that NOT a silver mark ; it will not capture your development process that way. You can read Steve Yegge's excellent Agile Development article to balance advertising.

Cherry-picking, some aspects of agile development can be difficult if you do not understand the core of Agile. Agile is more than just another way of thinking : to be flexible, to accept that everything will change, to write short short iterations, focused on getting one or more functions completed . The opposite of receiving a single, complete, monolithic specification, writing all the code, documentation, and then sending it.

If you want to prove that Agile Development works, I would probably vote for a sprint to show what “release before, release often” means.

Answer 7

It depends entirely on your existing process, but I’ll tell you that one of the best steps we took was to get the concept of an element lagging and a daily 3-question (what did you work after the last time we met "are you going to work today? What are the obstacles that prevent you from moving forward?) to meet in the morning to see where we are and what we can do to move forward to our end point of the short iterative cycle.

It’s good to be able to see a dynamic lag in work and what is working now and what will do it at the next iteration. It’s good to be able to get an idea of ​​where individual developers are and help them remove any obstacles to moving forward. It keeps developers from the dark .

Anyway, this is my thought. It worked for us.

Answer 8

Start by testing the modules if you are not already doing this. If you are testing a device, switch to test development. They can easily be added to existing processes and will pay immediate dividends. When you are ready for process changes, bring iterative development. If your current process is already iterative, start making frequent releases of your iterations to clients to get feedback.

If I had to summarize the “flexible” way, I would say that offering high-quality business value early and often. The above practices will help you go a long way along this path.

[EDIT] I suggest that I propose a flexible approach to adopting flexible methods and start with simple things that immediately bring great value.

Answer 9

Automated tests performed in automatic assembly.

Answer 10

I would try to go with Test Driven Development. This will give you many things:

• You get pretty good unit test coverage (I'm not saying unit test coverage is important).
• Developers will have more confidence that the code really works (see * later for more information)
• You can easily reorganize the code (because you have tests).

---

[*] - Kent Beck mentions influence charts in this area. In the influence diagrams, an arrow between nodes means that an increase in the first node implies an increase in the second node. The arrow with a circle means that increasing the first node implies decreasing the second node.

-----> [Stress] <--o-- / --o--> [RunTests] 

The more stress you feel, the less you will experience. The less you test, the more mistakes you make. The more mistakes you make, the more stress you feel. Repeat ...

How to solve this circle, which leads to the fact that developers do not trust their own code after a while?

The first development test changes the influence diagram:

 [TestFirst] <--o-- / --o--> [Stress] 

The more you test the first development, the less stress you feel. The less stress you feel, the more tests you do first.

This leads to improved testing code developed by developers who trust their code.

Answer 11

In addition to all the good tips already provided and with which I agree, I would suggest strengthening QA with automatic, repeatable tests. Investing in automation will allow you to be more confident when changing already deployed code.

Creation of regression sets for new functions simultaneously with their implementation.

QA can use exploratory testing as an alternative to finding holes in your development process.

Answer 12

I think the two most valuable and easiest to implement aspects of Agile are:

• daily stand - will hold a brief daily meeting with the team to view the status. Use 3 questions. Avoid crosstalk, chatter and sucking. Keep it fast and in place.

• iterations with short time intervals - breaking a project into two or three weekly cycles forces you to work on achievable goals in a reasonable amount of time