Chapter 2 Iterative & Evolutionary Flashcards
What is the Iterative Development?
Iterative development is an approach to building software (or anything) in which the overall lifecycle is composed of several iterations in sequence. Each iteration is a self-contained mini-project composed of activities such as requirements analysis, design, programming, and test. The goal for the end of an iteration is an iteration release, a stable, integrated and tested partially complete system.
What are Risk-Driven and Client-Driven Iterative Planning?
Risk-driven iterative development choses the riskiest, most difficult elements for the early iterations. For example, maybe the client says “I want the Web pages to be green and the system to handle 5,000 simultaneous transactions.” Green can wait and in this way, the highest risks are surfaced and mitigated early rather than late.
Evolutionary and Adaptive Development
when planning projects that can change and adapt over time (like evolution), it’s not true that we can never guess how much time or resources they will take. However, at the start, it’s harder to make accurate guesses because things often change and we don’t have a lot of information. This early stage, where it’s really uncertain, is known as the “cone of uncertainty.” As the project goes on and we learn more, making estimates gets easier. Usually, we wait until we’re a little way into the project, maybe 10% to 20% through, before we start making more reliable guesses about the cost, effort, or schedule.
This approach is similar to what managers do in other areas when they’re developing new products. They often start with a phase where they’re exploring and figuring things out. They also prefer adaptive planning, which means planning just a short time ahead in detail, because this matches better with the information they have at the time.
Fixed-Price Contract
when dealing with set-price projects and changing estimates, some methods recommend dividing the project into two main parts, each with several short cycles.
The first part is a short, fixed-time and fixed-price phase where the goal is to do a bit of software development and start figuring out what the project really needs. Importantly, this phase results in actual software, not just plans or documents.
After the first part is done, the software that was made, along with everything learned, is shown to companies or teams who might want to take on the next part of the project for a set price. The work done in the first phase makes it easier to guess how much the rest of the project will cost and improves the software for the next steps.
Incremental Delivery
ncremental delivery involves gradually releasing a product to users in parts, each with more features than the last. This approach, used by iterative and agile methods, typically sees new releases every three to twelve months. It’s different from iterative development, where short cycles improve the product internally but don’t necessarily result in immediate releases. With incremental delivery, each major update is shared with users or the market.
Evolutionary Delivery
evolutionary delivery is an advanced way of delivering projects in small parts. The main goal is to constantly get feedback from users about the product that’s already out there, and use that feedback to decide what to do next. This approach aims to address users’ needs that are hard to predict ahead of time, like what new features they might want most. The unique thing about the Evo method is that it tries to make these update cycles really short, like one or two weeks, so users get useful updates frequently.
When comparing this to just incremental delivery, where you have a set plan for what you’re going to deliver in the future and stick to it without much change, evolutionary delivery is different because it doesn’t really have a set plan. Instead, what you deliver next is decided as you go, based on what feedback you’re getting. In reality, most projects use a mix of planning ahead and adapting based on feedback, even if these two ideas sound different.
cone of uncertainty
Evolutionary and adaptive planning in projects, such as software development, acknowledge that not everything can be known from the start. At the beginning of such projects, it’s hard to predict exactly how long everything will take or how much it will cost because requirements might change as the project progresses. This uncertainty is like starting a journey without knowing all the turns you’ll need to take.
As the project moves forward and more information is gathered, this uncertainty decreases. It’s similar to navigating through a foggy path; the further you go, the clearer the path becomes. Teams adjust their plans, schedules, and estimates based on new information and learning, which is why it’s called “adaptive” planning. They don’t just make a plan once and stick to it no matter what. Instead, they adapt and evolve their plans as they learn more about what’s needed, how long tasks really take, and what challenges may arise.
This approach doesn’t mean that projects are without any boundaries or that deadlines and budgets can stretch indefinitely. Rather, it acknowledges that flexibility in planning is necessary to accommodate changes and that more accurate estimates become possible as the project team gains a better understanding of the work involved. This way of planning tries to balance the need for flexibility with the need for some level of predictability in project outcomes.
adaptive planning
Adaptive planning is like planning a big road trip with the idea that you might change your route along the way. At the start, you have a general plan: where you want to go and some places you’d like to visit. But you’re open to changing your plan as you go. Maybe you hear about a really cool spot from someone you meet, or you find out one of your planned stops isn’t as interesting as you thought.
So, instead of sticking to the original plan no matter what, you decide where to go next based on the latest information and what you’ve learned so far. This way, you can make the most of your trip, seeing the best sights and avoiding any issues on the road.
Adaptive planning in projects works the same way. You start with a plan, but you’re ready to change it as you learn more and as things happen. This helps you deal with unexpected issues and take advantage of new opportunities, making sure the project turns out as well as possible, even if it ends up being different from what you first imagined.
Predictive Planning
Predictive planning is like setting out on a road trip with a detailed map and a clear plan for every step of the journey. Before you even start, you decide exactly which roads you’ll take, where you’ll stop, how long you’ll spend at each stop, and when you’ll arrive at your destination. You stick to this plan as closely as possible, even if you hear about an interesting detour or encounter minor roadblocks.
In projects, predictive planning means you try to figure out everything that needs to be done from the beginning. You make a detailed plan for the whole project, including what work will be done, how long it will take, and how much it will cost. The idea is to avoid surprises by planning everything in advance and sticking to the plan as much as possible. This works best for projects where what you need to do is clear from the start and unlikely to change much along the way.
