blog Scrum Anti-Pattern Scrum Team ScrumMaster sprint Sprint Planning Work In Progress

Scrum Anti-Patterns: Hardening Sprints | Agile Pain Relief

Hardening Sprints are probably the most widespread kinds of Scrum Anti-Patterns: ways of addressing recurring problems that seem like efficient solutions on the time however in reality hamper productivity or create more issues afterward. Right here we introduce why they’re used, why they don’t seem to be an efficient design sample, and how one can create simpler solutions.

In software improvement work, a design pattern is an outline of a solution to a recurring drawback. It outlines the elements which might be vital to unravel the issue, together with context and the results of certain actions, with out prompting the reader to unravel the issue a selected means, leaving them with the company to write down code as they see fit. Patterns, when utilized properly and not overused, provide a information to fixing repetitive problems quickly. A superb sample supplies sufficient background info to assist the reader recognize where it’s applicable, with out declaring that’s the greatest answer in all situations.

Scrum, Agile, and Kanban, in this sense, are sets of behavioural design patterns. In the Scrum Group, we now have Scrum PLOP (Pattern Language of Packages) that documents recognized patterns of effective behaviour.

Unfortunately, we also frequently see recurring patterns of ineffective behaviour. These are referred to as Anti-Patterns.

“An anti-pattern is just like a pattern, except that instead of a solution it gives something that looks superficially like a solution but isn’t one.”  ~ Andrew Koenig[1]

Scrum as an strategy is already designed to cope with the unpredictable, with out having to drive exceptions. Every time a group creates an exception, reminiscent of a particular Sprint to unravel a problem, it creates an Anti-Pattern, which frequently leads to further issues.

The following is an exploration probably the most widespread Anti-Patterns: the “Hardening Sprint.”

Anti-Pattern[2] Identify: Hardening Sprint

Aliases: Stabilization, Hangover, Launch Dash, or IP Iteration (Innovation and Planning Iteration in SAFe)

Scale: Workforce and across a number of teams

Associated Anti-Patterns: Sprint 0, Separate Check Workforce; Element Teams; Technical Debt may be paid off later; Sprint Burndown Charts, Velocity is Necessary, ….

Potential Options:

  • Better Definition of “Done”
  • Enhance Engineering Practices
  • Slowdown

Why a Hardening Dash may look like a good suggestion

Teams new to Scrum typically give attention to getting as many Consumer Stories finished as they will each Sprint. If they’ve good discipline, they write Unit Checks for his or her code. As soon as complete, they ship the function off to their overburdened testers. In Dash Evaluate, the function is accepted by the Product Proprietor. If defects are discovered, they’re added to the Product Backlog in a decrease precedence slot.

While this sounds positive on the floor, hassle could also be brewing. If they finish Consumer Stories to the Definition of “Done” however that definition still leaves some issues to be dealt with later, ultimately it’s going to catch up to them.

After 5 or 6 Sprints at this pace, they could elect to pause and have a “special” Sprint, or Hardening Sprint. They use this Dash to do all the work that they postponed in the course of the working Sprints. The delayed work typically consists of duties akin to operating a regression check suite, doing performance checks, and fixing defects. Typically more defects are found than could be fastened. Once the Hardening Dash is full, the Product is released to Production.

While that is widespread follow, it’s not in the spirit of Scrum. Scrum is intended to assist groups study the rigour and self-discipline to ship working software program on the finish of every Dash. Clearly, having a Hardening Sprint as part of this process permits the Workforce to avoid dealing with that problem, subsequently turning into an anti-pattern.

Teams who’ve spent a very long time working in a waterfall style typically elect for Hardening Sprints. This isn’t shocking since Hardening Sprints appear to be a logical alternative for the testing and deployment phases they’ve been used to. However that’s only as a result of Teams new to Scrum haven’t but felt the pain that’s brought on by these particular Sprints, in order that they’re extra more likely to fall into the lure of considering they’re the solution to the troublesome query of learn how to deliver working software at the finish of each Dash.

Consequences of utilizing Hardening Sprints

A Casual Loop Diagram of a Hardening Sprint

Hardening Sprints are primarily the Scrum builders’ version of “we’ll fix it in post.” They have a tendency to lower the readability of the code base as a result of individuals have a behavior[3] of delaying any tidy-up work until then. The messier the code is to learn, the more durable and extra time-intensive it is so as to add new features or check present ones. Many people name this Technical Debt.[4] It doesn’t take lengthy before the workforce wants so as to add more time into the Hardening Sprint to get the work absolutely tested.

Hardening Sprints have damaging downstream penalties too. By delaying the discharge of a working product to the client, we delay when they may pay us. Typical or Waterfall approaches to product improvement delay tasks like testing and writing documentation to the top of the development process. Once we delay work until a Hardening Sprint, we’re dragging a waterfall strategy into an Agile setting.

Using Hardening Sprints results in:

  • A larger volume of untested code – Many types of testing (regression, efficiency, usability, and so forth.) are postponed until the Hardening Dash.
  • Defects troublesome to resolve – The longer we delay in fixing them, the more durable they are to repair, both because the one that wrote them forgot their intention and code base could have advanced so we could also be counting on the faulty behaviour elsewhere.
  • An increase in defects which are either not found or discovered later – The more time that passes between writing code and testing it, the more durable the defects are to seek out. In many instances, because of the ever-growing complexity, the defects are by no means found.
  • Delay for the client – In real Scrum, the client can use the Product Increment (aka Working Software program) on the end of each Sprint. With Hardening Sprints, they get entry only after the Hardening Dash. If Hardening Sprints happen every 5-6 Sprints, meaning a minimum of three months with out new software program and real engagement.
  • An increase within the complexity of the regression exams **ultimately** requiring a rise in the time spent doing Hardening Sprints – As the code base grows, so do the variety of check instances. Ultimately, one Dash isn’t sufficient to run them all (let alone fix the defects) so we schedule another Hardening Sprint.
  • Harder to tidy messes after they’re found because the code base is more fragile – Lacking good unit checks and automated acceptance checks, making modifications turns into more durable because we don’t know if we will trust that our change is sweet. Typically we avoid making modifications (e.g. refactoring) as a result of the modifications are “too risky.”
  • Regression Check instances run by hand (or manually) being error-prone[5] – We’re counting on individuals noticing errors in software that they have seen many occasions earlier than. Even probably the most careful tester will miss issues as a consequence of this type of repetition blindness, referred to as the Observer-Expectancy Impact.[6] Relying on individuals to do repetitive process work is error-prone and boring for the individuals.

If you want maintainable software, then you need to remove the Hardening Dash. Giant-Scale Scrum hints at the drawback by calling anything not really accomplished within the Dash as “Undone Work.”[7]

Typical Causes

  • A belief that teams have to work quicker from the start
  • Concentrate on growing velocity, without first specializing in quality
  • A “traditional phased” strategy to Scrum
  • A weak or non-existent definition of “Done”
  • Lack of rigorous engineering practices
  • A perception that multi-Staff efforts require additional integration time earlier than they’re able to launch
  • SAFe [8] suggestion (referred to as an IP Iteration)

Solutions

  • Improve Definition of “Done”
    • Giant-Scale Scrum calls the distinction between Probably Shippable and Definition of Accomplished “Undone Work.”[9]
  • Improve Engineering Practices

Each of the above ought to outcome in the Workforce discovering Agile Check Engineering Practices similar to Specification By Instance/BDD/ATDD, and so forth.

  • Decelerate. Don’t give attention to velocity – as an alternative, give attention to high quality.  (Which ought to end result in the workforce focus of learning. This should, in turn, discover Agile Check Engineering Practices.)
  • Deliver working software program on the end of each Sprint. (Which should refocus on Definition of “Done” and Agile Check Engineering Practices.)

Realistically, there is only one answer to the challenge that Hardening Sprints symbolize: scale back the variety of time-demanding issues that get pushed forward to be a future drawback. A lot of the work that’s delayed to a Hardening Sprint is comprised of pieces of labor which might be executed manually. For instance, many software program groups have a set of regressions checks that require a person to execute a collection of steps in the software program and examine the results. That takes hours of labour, so to have the assets and capability to run these exams each Dash, we need to scale back the general guide load.

To scale back the variety of guide duties, a staff might:

  • Take one or two check instances each Sprint and discover methods to automate them. It is typically simpler to automate within the area the group is already doing function work. Caveat: the default strategy to check automation – automate the GUI [10] and watch the outcomes – is usually not efficient in the long run. Nevertheless, effective check automation is beyond the scope of this blog entry.
  • Slow down. Since automated testing will require new expertise, the workforce needs to decelerate and take time to study. Too typically it’s assumed that staff members will study by osmosis.
  • Prioritize fixing defects. Delaying the repair simply will increase the complexity of the eventual repair and the code base. If as an alternative, the Product Owner places defects at the prime of the Product Backlog once they’re found, they’re additionally sending the group a clear message: concentrate on quality.
    Associated to defects are those messes (incorrectly referred to as “Technical Debt”[11]) in the code base which might be under the level that the Product Proprietor can see. In the event that they’re small (e.g. 15-30 minutes work) they need to simply be fastened instantly. If they’re larger, they warrant a discussion with the group on how that part of the code could be improved as a part of their ongoing work.

Groups that comply with this strategy nicely shouldn’t only get rid of their Hardening Sprint, however they should additionally have the ability to be a part of the teams that do true Steady Deployment/Supply.

If finished appropriately, Groups will ultimately wander into the realm of DevOps simply by getting extra really carried out each Sprint.

One shopper started to get so good at this that their staff began to do documentation work in Dash. They have been noticing that some elements of their product have been arduous to elucidate, in order that they took that as a hint and reworked the software program to be simpler to use, moderately than delay and simply push the issue to the longer term. By not suspending the problem, they delivered a better quality product.

In Licensed ScrumMaster training, when discussing the Definition of “Done”, I often reveal my true feelings and name Hardening Sprints what they need to be referred to as: an abomination. Or a slightly gentler version: Hangover Sprints.

Do you need to coach your staff in the direction of better options?

Basically altering the best way a Group works because it transitions to working towards Scrum is likely one of the tougher problems with creating high-performance groups. If you need to discover ways to handle points that organizations face like this one in their Scrum evolution, think about attending considered one of our workshops, where you’ll obtain hands-on studying of the challenges – and solutions – and recommendations on the way to combine them into your Scrum.


[1] An anti-pattern is a standard response to a recurring drawback that’s often ineffective and risks being highly counterproductive. ~ Wikipedia
[3] In the worst instances they could even be unaware of the need to tidy up.

[4] It isn’t Technical Debt as originally outlined by Ward Cunningham. See: https://www.ronjeffries.com/articles/019-01ff/tech-debt/ – Cunningham’s Technical Debt was meant to be a design tradeoff deliberately finished now, permitting the group to finish work quicker, with the intention of returning later to repair the debt. Most use of the time period in the present day must be referred to as Technical Mess or Spaghetti.
[5] This isn’t explicitly part of the Negatively Reinforcing Suggestions Loop image since Hardening Sprints and Guide Regression Testing are two sides of the identical coin. Groups use Guide Regression check suites that develop ever longer, which delay that testing until the Hardening Dash, and so begins another cycle.