Disciplined Agile

Recently on a LinkedIn discussion forum people were sharing their opinions about agile teams. Throughout that conversation I heard several statements which just didn’t ring true with me. In some cases I suspect that the problem was they were thinking they were agile when they clearly weren’t and in other cases I suspect people were sharing ill-founded rumours about how agile works. I heard that everyone on an agile team must be highly skilled, that everyone on an agile team is a “jack of all trades”, and that people on agile teams are working so fast that they have no time to learn. Let’s examine each myth/misunderstanding one at a time.

Myth #1: Everyone on an agile team must be highly skilled
Agile lore recommends that you build teams where you ideally have all the skills you need to get the job done, this is called being a “whole team”. This doesn’t always happen at first. Recently I worked with a team that was clearly short on testing skills but they were actively addressing that problem by bringing people into the team with those skills. They will also be pairing to spread the skills out once these new people join the team. Call me crazy, but doesn’t building a team with people that have the requisite skills a good strategy regardless of paradigm?

Myth #2: Everyone on an agile team is a “jack of all trades”
Disciplined Agile Delivery (DAD) suggests that people strive to be generalizing specialists (not generalists, not jack of all trades). This means that you have:

• One or more specialties (you need to be able to do something useful)
• At least a general knowledge of the software process and the business domain that you’re working in (this enables you to communicate more effectively with others and streamline collaboration)
• The desire to increase your knowledge and skills

Granted, this is different than how some people staff traditional projects where they have specialists and then incur an incredible amount of overhead to get the job done. When you are new to agile you very likely have many people who are specialists on staff, perhaps they are focused on being a business analyst, on being a tester, on being a programmer, an architect, and so on. That’s OK, as they say you go to war with the army that you have. Over time you will want to actively support, and motivate people, to learn new skills from other people on the team (see next point). It’s also important to recognize that although someone may currently be focused on a certain traditional role today, that in the past they held other roles and as a result may have a broader range of skills, albeit rusty in some cases, than they may give themselves credit for. Regardless of your situation people can easily gain new skills if they choose to.

Myth #3: People on agile teams are working so fast that they have no time to learn
Yes, agile teams focus on producing real value on a regular basis, and that is often perceived as working fast by people used to the less disciplined strategies of the traditional world. This is overwhelming at first for teams new to agile and it can seem that there isn’t time to learn or to even catch your breath. As you get better at working in an agile manner, as you “figure it out”, your team will settle on a rhythm that works for them.

Agile promotes iterative, collaborative, and experimental strategies. This promotes learning within the team, it doesn’t reduce it. Agile, and lean strategies in particular, expect the team to learn as you go. They’ll learn more about the domain, about the technologies they’re working with, about how to work effectively, and about each other. When people work together collaboratively, not alone at their own desks, they start to pick up skills from one another naturally. This is particularly true when the team adopts non-solo strategies such as pairing (I alluded to the value of pairing programmers and testers earlier). Of course coaching and mentoring are important to support learning as well as training.

I often run into people who are concerned about changing requirements, or evolving requirements if you like that term better, on software development projects (or product teams as the case may be). This is typically a reflection of their training and background in traditional software development strategies where changing requirements are usually perceived as a problem.

In agile we consider changing requirements to be a good thing and we even embrace the idea that this will happen.  In fact, one philosophy of Disciplined Agile Delivery (DAD) is that changing requirements are a sign of a healthy relationship with your stakeholders. Changing requirements indicate that:

• Your stakeholders are interested in what you’re working on
• Your stakeholders are thinking about what you’re producing
• There are feedback mechanisms in place that enable your stakeholders to change their requirements
• It is easy (hopefully) for stakeholders to change their requirements as their understanding of their needs evolve

So how do you support changing requirements in practice?  The Disciplined Agile (DA) toolkit includes the “Address Changing Stakeholder Needs” goal which guides you through understanding and selecting the right strategy for prioritizing requirements changes as they occur throughout the lifecycle.  These strategies include, but aren’t limited to Scrum’s Product Backlog Strategy, a more disciplined Work Item List strategy, or a lean Options Pool strategy.  In regulatory situations you may even want to consider a formal change management strategy.  DAD’s process goal-driven approach enables disciplined agile teams to tailor their strategy to meet the situation that they find themselves in, avoiding the challenges seen with methods such as Scrum that prescribe a single strategy (in this case Product Backlogs) that don’t work in all situations.

And of course, to minimize the pain of changing requirements you will need to adopt disciplined development practices such as:

• Writing high-quality code;
• Refactoring your work to keep it of high quality;
• Continuous integration;
• and even acceptance test-driven development (ATTD)/behavior driven development (BDD).

Recently on the DAD LinkedIn discussion forum we’ve had an interesting conversation going on that strayed into the effectiveness of various communication techniques.  This conversation got me to thinking a bit about an article that I first wrote over a decade ago, Communication on Agile Software Projects, based on material in my Agile Modeling book.  This article extends some of Alistair Cockburn’s thinking on the topic, summarized in Figure 1, which in turn extends a body of work called Media Richness Theory.  The basic observation is that the richer the communication channel – such as email, videoconferencing, or face-to-face conversation – the more effective it is in practice.

Figure 1. Comparing the effectiveness of communication techniques.

In the DAD book Mark and I said that the implication of Figure 1 was that given the situation you find yourself in that you should choose to use the most effective communication strategy available to you.  We thought that this was all that needed to be said, but since then we’ve come to realize that a better diagram is needed.  We developed Figure 2 which we believe communicates this strategy a bit more clearly.

Figure 2. Choosing the best communication technique for your situation.

Figure 2 indicates that that the viability of communication options available to you varies depending on the situation that you find yourself in.  For example, people on a co-located team can communication in pretty much any manner they choose.  Ideally they would choose face-to-face communication around a whiteboard or paper but there’s nothing stopping someone from writing a detailed document and then emailing it to someone sitting beside them.  When a team is geographically distributed they have fewer communication strategies available to them, unless of course they invest in travel so that they can be face-to-face.

Figure 2 also indicates strategies for capturing, or persisting, a conversation.  For example, a few people could have a conversation around a whiteboard, sketching the design of a screen perhaps.  When they’re done they might decide to take a digital snapshot of it so that they can retain the diagram to work on it later (many organizations still don’t provide permanent whiteboard space to their development teams).  They may even choose to have someone write up notes, perhaps on a wiki or in a word processor, and embed the snapshot(s) into those notes.

To summarize, when it comes to how people communicate with one another they have choices.  Disciplined agilists prefer to choose the most appropriate communication strategy for the situation that they find themselves in.

We’ve recently been asked how risk management is addressed on agile teams. This is an easy question to answer because risk management strategies are built right into the Disciplined Agile (DA) toolkit.

Let’s start with two definitions. First, a risk is an exposure to a potentially negative outcome. Risks come about from uncertainty. Second, risk management is the identification, exploration, and mitigation of risks. Risk management should be part of both your team management efforts, even on self-organizing agile teams, as well as part of your organizations governance efforts.

Regardless of your delivery paradigm, there are several common categories of risks faced by IT delivery teams:

• Business risk. This includes significant shifts in requirements due changing business priorities, often due to realization new market opportunities, in reaction to moves made by competitors, or because you are opening completely new market opportunities. Another common risk is an overly optimistic/aggressive schedule which motivates your team to take unfortunate shortcuts. A third type of business risk is a misaligned budget: either there isn’t sufficient funding to do the job effectively (e.g. there’s no travel budget for a geographically distributed team, there’s no funding for coaching on a team new to agile, there’s no funding for training, and so on) or there is far too much funding available and the team is motivated to invest it in wasteful activities.
• Technical risk. IT teams face technical risks as the result of combining technologies in new ways, evolving technology platforms, new technologies, and lack of experience within the team in these situations.
• Operational risk. This category of risk pertains to production-oriented issues surrounding the support and operation of a solution. Will your solution work within the existing organizational ecosystem? Does your operations team have the skills and resources to run your solution? Does your support/help desk team have the experience and knowledge required?
• Process risk. As DAD clearly shows, every technique has advantages, disadvantages, and specific situations where the technique makes sense. The implication is that there are risks taken on when you apply a technique outside of its range of applicability or your comfort zone.
• Organizational risk. IT teams face organizational risks such as dysfunctional politics, competing visions, challenges pertaining to your agile transformation challenges, reorganizations, and many others.

Recognizing that IT delivery teams must deal with risks on a regular basis DAD builds in several agile risk management strategies:

• Continuous engineering practices.  This is a collection of practices with very short feedback cycles, thereby enabling you to adjust course quickly. These practices include behavior driven development (BDD), test-driven development (TDD), continuous integration (CI), continuous deployment (CD), and many others.  All of these practices require discipline and skill to adopt.  Although these practices are technical in nature, in practice they mostly reduce business risk through shortening the cycle between a stakeholder having an initial idea and the team providing a solution which reflects that idea.
• Agile architecture practices.  The DA toolkit suggests a collection of continuous architecture strategies throughout the entire lifecycle.  These include, but are not limited to, identifying an initial technical strategy, proving the architecture early in construction, deferring architecture and design decisions to the most appropriate moment, architecture spikes, just in time (JIT) model storming, and many others.  These practices reduce technical risk.
• Risk-value lifecycle.  The DA toolkit supports several lifecycles, and hence several work prioritization strategies.  One such strategy is the Unified Process (UP)’s risk-value approach where both risk and value are considered when prioritizing work items.  The end result is that work items with higher technical risk are implemented early in the lifecycle, enabling disciplined agile teams to mitigate technical risk early in the effort.  DAD teams then follow Scrum’s value-driven approach where the work is prioritized based on its business value to the organization, which is effective at addressing some forms of business risk.  The risk-value prioritization approach results in a lower overall risk profile than just the value-driven lifecycle of Scrum.  DAD also supports lean and continuous delivery versions of the lifecycle which expand upon the risk-value strategy to consider other factors such as required release dates and team health considerations.
• An explicit Inception phase.  The fundamental purpose of the Inception phase is to help your team get going in the right direction.  Executed properly, the Inception phase helps you to reduce business risk by coming to stakeholder agreement regarding the team’s strategy, technical risk by exploring a viable technical strategy, and operational risk through planning with production-staff from the very beginning.
• Risk-based, light-weight milestones.  The DAD lifecycles include explicit milestones as part of DAD’s overall governance strategy.  These milestones motivate teams to address common issues such as formulating an agreed-to vision early in the effort (business risk), proving the architecture early (technical risk), regularly considering the viability of the effort (business risk), ensuring the team has produced sufficient functionality to justify deployment (business risk), ensuring the solution is production ready (operational risk), and ensuring that the stakeholders are delighted with the result (business risk, organizational risk).
• Development intelligence.  One of the governance strategies that the DAD process framework promotes is development intelligence (DI) where a team/project dashboard is populated with metrics generated automatically by the tools the team is using.  This provides real-time insight for the team to organize itself and potentially improve its approach.  It also provides insight into your organization’s governance effort, supplying real-time data which can enable senior management to make better decisions and thereby better support your agile teams.  Development intelligence, and it’s extension IT intelligence which addresses the entire IT portfolio and processes, helps you to reduce process risk and to a lesser extent organizational risk.
• DevOps principles and practices. DAD weaves DevOps strategies through the entire framework.  This strategies are: Including operations and support staff as explicit stakeholders who work closely with the team; the lifecycle explicitly depicts production/operations; DevOps-oriented milestones (Production Ready and Delighted Stakeholders) are included as part of the governance strategy; development practices such as instrumenting solutions for operational monitoring, continuous deployment, and installation testing (to name a few); and management practices such as deployment planning. The strategies help to reduce both operational and organizational risks.
• Sophisticated go-forward decision points.  One of the business risk management strategies promoted by Scrum and RUP is to make a “go/no-go” decision at the end of each sprint/iteration.   DAD takes this strategy further by recognizing that you have several options to consider – your team can continue with its current approach (go), it can stop (no-go), it can decide to change direction (pivot), or it can decide to experiment (run a split test).  The two new options are adopted from Lean Startup. DAD’s lean and continuous delivery lifecycles promote the idea that you make these go forward decisions when you need to, that you don’t need to wait until the end of an iteration to do so.
• Risk-oriented process goal.  The DA toolkit promotes a non-prescriptive, process goal-driven approach.  DAD explicitly includes a goal, Address Risk, the goal diagram for which is presented below in Figure 1.

Figure 1. The Address Risk process goal.

• IT risk management is built in. IT-level risk management is built into the IT Governance process blade.  Although a risk may be small for a single team, when that same risk is taken by multiple teams in parallel in aggregate the risk may be more than your organization should take on.  Hence your risk management efforts at the delivery team level must be monitored regularly and aggregate risks mitigated appropriately. The process goal diagram for IT governance is shown below in Figure 2.

Figure 2. IT-risk management is an aspect of IT Governance.

Risk management isn’t explicitly built into first generation agile methodologies like Scrum or XP, although a handful of implicit risk mitigation techniques are.  As a result you still need to develop a risk management strategy for yourself when you limit your team to these sorts of agile methods.  The DA toolkit, on the other hand, has built risk management strategies into the toolkit in a lightweight and comprehensive manner.  From the point of view of process risk, having such guidance built into your process is a low-risk and desirable approach.  For further reading about risk management, we highly suggest the list of references maintained by Glen B. Alleman.

I was recently asked how is technical debt addressed in Disciplined Agile Delivery (DAD), a very important question.  Because DAD promotes a full, explicit delivery lifecycle there are many opportunities to first avoid creating new technical debt in the first place and second to address existing technical debt appropriately.

Here are some of the strategies that DAD promotes when it pertains to technical debt:

1. Do a bit of up front thinking.  One of the process goals of DAD is Identify Architecture Strategy.  By thinking through critical technical issues before you implement your solution you have the opportunity to avoid a technical strategy which needs to be reworked at a future date.  The most effective way to deal with technical debt is to avoid it in the first place.
2. Have an explicit architecture owner.  The Architecture Owner (AO) on a disciplined agile team is responsible for guiding the team through technical decisions, particularly those at the architecture level.  AOs often mentor other team members in design skills, skills that should help them to avoid injecting new technical debt into the environment.  They should also be on the lookout for existing technical debt and where appropriate motivate the team to address that technical debt when appropriate.
3. Be enterprise aware.  Disciplined agile teams are enterprise aware, realizing that what they do should leverage and enhance the overall organizational ecosystem.  They will work close with your enterprise architecture and reuse/asset teams, if you have such, so that they can take advantage of existing assets.   Assets could include code, patterns, services, templates, guidelines, or anything else worthy of being reused.
   An important strategy for avoiding technical debt is to reuse existing assets and not rebuild or rebuy something that you already have.
4. Refactor technical debt away.  DAD provides guidance for when to apply several forms of refactoring, including code refactoring, database refactoring, and user interface (UI) refactoring.  Refactorings are typically very small, such as renaming an operation or splitting a database column, so should just be part of everyday development.  Rework, on the other hand, is more substantive and should be explicitly planned.  The Architecture owner will often negotiate rework-oriented work items with the Product Owner (the person on the team who is responsible for prioritizing the work).
5. Regression test continuously.  One of the easiest ways to find problems in your work is to have a comprehensive regression test suite that is run regularly.  This test suite will help you detect when defects are injected into your code, enabling you to fix them, or back out the changes, right away.
6. Automate code/schema analysis.  There are many tools available for assessing the quality of your code and even your database schema.  Disciplined agile teams will include the use of these tools in their continuous integration (CI) strategy.  Knowing where your technical debt exists is the first step in removing it.
7. Measure technical debt.  Organizations that are serious about technical debt measure it, something that code/schema analysis tools help with, and more importantly keep an eye on the trends (which should be going down over time).  You may choose to track code quality metrics, data quality metrics, usability metrics, time to address defects, time to add features, and many other things.
8. Explicitly govern technical debt.  Several of the previous strategies require investment that some organizations wouldn’t normally consider to be part of the mandate of a delivery team.  For your organization to succeed at reducing technical debt it must be governed, albeit in an agile fashion.  This means it needs to be understood by senior management, measured (see previous point), and funded.  The DA tool kit includes explicit guidance around how to govern agile teams effectively.
9. Reducing technical debt should be part of your culture.  Technical debt isn’t going to fix itself, and worse yet will accrue “interest” over time in the form of slower and more expensive evolution of your existing assets.
10. Address technical debt before handing over an asset.  Passing systems with high technical debt to other teams, such as a sustainment team or maintenance group is generally a bad practice. It should be ingrained in your culture that each team is responsible for keeping the quality of their solutions high. It is reasonable to expect maintenance groups to resist accepting systems that have high technical debt.
11. Accept some technical debt.  Sometimes you will decide to explicitly accept some short term technical debt for tactical reasons.  Perhaps you need to get something developed quickly because you are running a market experiment (a la Lean Startup).  Perhaps there is a new component or framework about to be delivered by another group in your organization, so you’re writing a small portion of what you need for now until you can replace it with the more robust asset.  Regardless of the reason, part of the decision to accept technical debt is to also accept the need to pay it down at some point in the future.  Having good regression testing assets in place assures that refactoring accepted technical debt in the future can be done with low risk.

There are many good online resources regarding technical debt, and the best single one that we have found is Israel Gat’s blog.   Technical debt is real and you need a viable strategy to manage it.  Otherwise you run the risk of slowly choking the life out of your organization’s IT infrastructure.  The DA too lkit can help you to understand how the strategies described above fit into your overall agile delivery process.

Related Resources

• The Spilled Juice Analogy for Technical Debt
• Data Technical Debt: How to Address Quality Problems in Data Sources
• Do Agile Teams Pay Down Technical Debt in Practice?
• Crushed by Technical Debt? (Webinar, earn 1 PDU)