How to hire a development team
This is the first of a series of posts for administrators, although programmers should read them, too.
As a business person, you are focused on the big picture, and you need your contracts to be precise to avoid unpleasant surprises. So here is my question to you:
Would you hire a software development company that works via the Waterfall method?
Yes or no? Would you hire them to make software for you?
If you don't know what Waterfall is, you are in the right place.
By the way, the correct answer is no, you mustn't, because Waterfall is a severely obsolete way to develop software, and likely to fail hard. But Waterfall continues to be used today, since it feels comfortable to administrators who do not know certain strange facts about software development.
Waterfall means each development phase is done for the entire scope of the project and its output informs or cascades into the next phase:
Requirement gathering & analysis ↘ System architecture and design ↘ Implementation ↘ Testing ↘ Delivery / deployment ↘ Maintenance
The first phase, requirement gathering, results in a text that states the problem we are trying to solve. This text is the basis for work on the second phase, design, which is done by business analysts interviewing workers in your company, and results in a text (and some diagrams) that state what the solution is going to look like.
You pay for these 2 phases and, if you are happy with the proposal, you contract the team to actually develop the software for you. So you start paying for development, but basically you don't talk to the developers anymore, for months or even years, until they finish their job and come back to show you the result.
That output of the 2nd phase is the input for the 3rd phase, implementation, in which programmers make the software. The application is the input for the 4th phase, testing, in which testers find bugs in the software and send those back to the programmers to fix.
When testers are happy, you go to a meeting and you see what they did. Now you start pulling your hair because:
- Due to misunderstandings, what they are delivering is NOT what you asked for, months and months ago.
- Even if they had understood you, so many months have passed that what you asked for is no longer what you need. During this time, your business has evolved, your customers have changed, regulations have changed, the market has changed etc.
- There are features missing which are evident now, but nobody thought of then.
- The project is late and you have already been forced to negotiate the price, paying more for them to finish the job.
Historically, the Waterfall method had these serious problems:
- It naively assumed that the system could be planned in its entirety; it did not foresee changes in scope.
- Each step took months to do, so projects could take years to complete.
- Clients did not participate in the development process, they only saw the finished project at the delivery phase.
- For lack of communication, clients felt what was delivered had almost nothing to do with what they had said they wanted.
- By the time the project was completed, the plans were obsolete: so much time had passed that the solution was born inadequate. Even if there had been no communication issue.
- Each phase was driven by fear of incompleteness. Most importantly, during the initial requirements gathering, clients tried to be as complete as possible in listing features, for fear of leaving out something important while they still could add scope without incurring costs. This resulted in implementation of many features that were never used in practice – an enormous waste of time and money. This problem is called "feature creep".
- Due to lack of communication and lack of trust, negotiation was hard. Clients simply wanted as much scope as possible for as little money as possible. It was hard for clients to understand why no software project can be delivered in the estimated time (more about this in another post). If legislation changed during the project execution and the scope had to change, a negotiation had to take place.
Software projects are very different from other projects. Software has weird characteristics that you, as a business person, must know about, if you are to succeed. This is what this small series of blog posts is about.
Fixing waterfall
Around the turn of the century, Waterfall was gradually abandoned, in favor of some Agile methodologies. But here is the problem: Agile is hard to understand.
Let's just try to begin to understand Agile.
The word Agile does not mean faster. Nothing gets done faster. It just means our reaction time is shorter. When the environment demands we move in another direction, we are ready to do so. We are a motorcycle, not a train. A motorcycle is not necessarily faster than a train; it is more agile.
What would you do to fix Waterfall? I have shown you its problems; what do you do?
Here are some obvious things:
- The client must participate all the time, not just at the beginning and at the end.
- There should be more communication.
- Planning should not be done only once at the beginning of the project. It should be done all the time, as reality changes and priorities shift.
- Place incentives to get rid of the fear of incompleteness. Tell them to make a small improvement and deliver it as soon as it is palpable to the user.
Therefore, when working with an Agile team:
- You are required to enter another kind of contract, with variable scope, as opposed to the fixed scope of the Waterfall method. In other words, the contract does NOT say what the software is going to do. Nobody knows what the software is going to do, exactly. That's going to be discovered during the project. You pay for development time, not for a fixed scope. As an administrator, at first, you preferred a fixed scope, but now you know it would cause the project to fail.
- You accept a Minimal Viable Product (MVP), start using it, and work with the team in short iterations, giving them priorities and meeting to see increments in functionality. The most painful aspects of the current software will always be very obvious to you.
- You must stay in touch with the development team to fix misunderstandings early and provide an updated north to them. In fact, you are part of the development team.
- The team avoids Almighty Thud Methodologies. The Almighty Thud is the noise that the documentation makes when it drops on someone's desk. Documentation is not software, though. It is only valuable in small portions.
- Everyone must understand that the scope changing... is the norm, it is the most common thing in the world, it is not to be treated as an exception, but as a rule. ("Embrace change" is the subtitle of Kent Beck's 1999 book on XP.)
Now I want you to look at the phases of a project again, because it is impossible to change these:
Requirement gathering & analysis ↘ System architecture and design ↘ Implementation ↘ Testing ↘ Delivery / deployment ↘ Maintenance
Our purpose is to reach Delivery. But we can't deliver something that wasn't Tested. And we cannot test something that was not Implemented. And we shouldn't implement something that wasn't Designed. And we cannot design something if we don't know what the problem is.
Therefore, the steps above are the same in Agile – but they describe only one iteration of many in the project. The iteration lasts only one or two weeks and works only on a small fraction of the system.
In Waterfall, you might choose to hire testers only near the end of the project. In Agile, everyone is working at the same time. The pains of one role can immediately be conveyed to relevant others. The system architect is immediately informed of the weaknesses in her architecture. The business analyst is immediately informed of the weaknesses in her output. The programmer immediately sees what kinds of bugs are being found by the tester. Everyone gets opportunities to improve – immediately, not just at the end.
- Instead of the feature creep characteristic of Waterfall, Agile prefers to deliver the smallest thing that has any value to the user as soon as possible. Even if it's just a single feature. The software is continually updated.
- We get feedback from the client and especially from users as early as possible and use that feedback in the following iterations. More likely that the right thing will be implemented. Less likely that unnecessary things will be implemented.
- Bring the client onto the development team, so there is transparency, they can actually see the hard work being done, they gain trust, and communication switches from negotiation mode to team mode.
- Even if communication fails hard at the beginning of the project, chances are it will improve and the right thing will be developed.
When do you stop the project? Well, it seems software needs to be maintained forever, to keep up with the times. But for new features, you know when to stop. Every two weeks you are focusing on adding the most important or most urgent feature(s). So you stop adding features when the cost of development finally becomes higher than the benefit of the remaining features listed in the product backlog.
Conclusion
Maybe Waterfall can succeed for projects that are small enough or very easy to understand and describe. For instance, a device driver for a mouse. But most software projects aren't like that, and then you need something that deals with the actual challenges, and that's Agile.
Since 2001 more or less, the software world started employing Agile methodologies. However, because of the exponential expansion of software, many do it without fully understanding it. Even today, many have heard the rooster announce dawn, but don't know where it is. They are just waking up to the new day.
There is nothing on the horizon that can replace true Agile, there is no newer idea worth our time. Our current problem is that our Agile must be true, that's it.
The next post will talk about other strange things typical of software development.