So is Agile just hype or is there something to it?

There are strengths to the agile way of thinking, and many of them bring useful perspectives to software and systems development that are new and even revolutionary. Here are some of the things that work — and, potentially, that radically change our old-world practices.

Whereas most legacy methods stem from industrial process — that is, assembling a product using a set of defined, predictable steps — the agile method is empirical. It recognizes that development is more like invention and research, more akin to scientific study, than assembly. This empirical nature is at the heart of the agile mantra: Deliver, measure, adjust and repeat. The strength of this approach often bears itself out in fantastically hyperproductive teams that deliver working product far more quickly than legacy methods, such as waterfall, could ever achieve.

Agile does this by cutting through complexity. Every agile-based methodology focuses on simplification of otherwise complicated problems. For example, XP and Scrum both emphasize development of near-term, complete deliverables. This means carving out tangible and reasonably independent pieces of work, focusing on that work, and then — at least as much as possible — moving on to other work. This approach requires that large, complex problems are broken down into manageable pieces and thought of on a micro-deliverable level. Likewise, this approach minimizes ceremony and eschews as much procedure as possible. Some agile methods go to extremes in this regard, focusing entirely on delivering work product and not at all on procedure. This translates into minimizing complexity on a large scale.

Closely related to eliminating complexity is agile’s focus on progress measurement. Most agile methods measure progress chiefly, if not exclusively, in terms of delivered work product. Most methods also are quite stringent in defining progress only when finished work is delivered, which means you can’t work for nine months on a single big feature. Instead, micro-deliverables target key features, deliver those features into the customer’s hands, then moving on to new features. This can be a huge strength because the customer gets working product in-hand to review early, and often. It involves the customer early in product evolution, leading to a host of benefits including better product targeting, prioritized development and improved quality.

These characteristics of agile methods combine to fundamentally change the way software and systems development is practiced. Agile also empowers individuals to become stellar performers. In fact, all forms of agile rely on this to some degree — with more lightweight agile methods being completely dependent on individual empowerment. The idea is that an empowered team will leap over constraints to get the job done, no matter how “out of the box” the thinking needs to be. It’s a refreshing concept and one that can indeed be supremely successful, but it does require the team to embrace the idea wholeheartedly.

Another benefit, at least in some situations, is the creation of self-organizing teams. Partly because of the light ceremony, the fast pace, and the penchant for empowerment and accountability, teams become self-organizing. This works when the team has the right make-up, as individuals step up to take on tasks best suited to individual skills. Self-organized, empowered teams become very powerful and very productive, provided that the team members are up to the job.

There is absolutely no doubt that agile methods make it possible to get things done quickly. That’s what it’s all about, after all. The real question to me is how much of this tradeoff is really desirable? How often do we want to eschew process and maturity in favor of getting things done quickly?

More importantly: Can we effectively merge the best attributes of Agility with the most valuable benefits of established processes and standards?

Why Agile doesn’t work

When an agile project fails, it generally does so spectacularly and predictably. The common failings of agile-based projects are just that… common. We see the same problems over and over again, and this has become the basis for many critiques of agile methodology. After all, if we keep seeing the same problems crop up again and again, isn’t this proof enough that the process is flawed? This becomes clear in hindsight, so why do we continue to see 90 percent of projects missing the mark?

The fact is, agile by itself is just one tool in the toolbox that should be applied with other implements of the trade. In my experience, the problem comes in most often because small- and mid-sized organizations experience brilliant success with agile and then assume it can work everywhere. They throw out the toolbox (or perhaps never buy one in the first place). Yes, agile can succeed. Yes, it can deliver fantastic productivity and stellar results. But not always — in fact, I will go so far as to say not often.

This isn’t because of agile’s limitations. Instead, it’s because of overconfidence by those putting it to use, and the mistakes an immature organization makes as it grows and applies it inappropriately.

Immature companies and teams are cutting their teeth, again and again, on the limitations of agile.

All agile methods make it easy to oversimplify complexity. In fact, agile’s strength of eliminating complexity might be better stated as “ignoring complexity.” There are appropriate situations for this but, more often than not, ignoring complexity leads to problems. Most business cases don’t call for undefined delivery dates or loosely changing requirements and partial deliveries. These are risks that most business models are incompatible with. If the risks aren’t something that your business can sustain, adopting a purely agile process is taking a huge gamble.

Likewise, focusing on the near-term is an agile attribute that introduces a lot of unknowns into the business-end of an equation. Few people will contend that agile is appropriate for mission critical efforts such as, say, launch vehicle development, as sometimes requirements need to be set in stone before anyone starts development. But what about situations where some degree of fuzziness is acceptable or even beneficial? Agile advocates compatibility with change, sidestepping change control procedures that would otherwise place tight controls over requirements. Requirements change carries with it a heavy burden, particularly when it comes to the cross-organizational impact to marketing, budget, quality management and the customer. However, cutting change control, requirements management, and configuration management from the process can lead to long-term disaster that the short-term perspective of most agile methods will overlook.

This theme of reducing structure and control has cut out many waterfall-origin processes. The danger often manifests as small-scale agile projects are successful, leading to wider-scale adoption of agile. But, as the projects grow in complexity and criticality, major missing components in the process become evident. For example, no agile methods today integrate comprehensive quality assurance procedures (in fact, thanks to some early mistakes, such as MIL-STD-498[#], most people think quality assurance is software testing — it’s not). Structured software testing often becomes an afterthought, and risk management programs tend to be regarded as “fuzzy disciplines.” Yet, these are the processes that successfully put man on the moon, that develop health care and financial services systems, and ensure that nuclear plant regulatory systems don’t fail after delivery. Of course, there is a cost to each of these processes, and every business needs to weigh the cost-benefit of adopting more process against cutting those processes. This needs to be an on-going evaluation, made as projects, organizations, and teams evolve — it’s not a decision that stands alone.

From a purely hands-on, management level, agile methods pose “people problems” as well. The strong emphasis on self-organization and empowerment can easily backfire. The former relies heavily on people that are capable of self-management and self-direction. Not everyone can live up to that expectation. The latter, delivering empowerment to the team and individual, can lead to a hero mentality and silo’d teams that refuse to play well with others. As projects grow in size, complexity, and dependency on other teams and resources, these characteristics become the drawback of an immature organization.

Almost all agile methods oversimplify valuable processes. In some situations, the project survives the oversimplification. Sometimes the business is tolerant of the fallout. In every case, agile methods expose the project to risks that stakeholders should be — and often are not — aware of.

What to do about it

We need to be cognizant that one solution does not fit all problems. While an agile method such as XP or Scrum may have led to success in one project, this doesn’t make it a foregone conclusion that it will do so again. Each project is different, and organizations evolve over time. Adopting one process to solve all problems is a sure recipe for failure. On the other hand, having a well-versed team that can draw on several methodologies, as appropriate for the job, is a recipe for success.

If your organization is looking for the one-size hammer to hit every nail, make sure it’s as configurable a hammer as possible. Don’t choose something that is either too lightweight, such as XP, because many projects will overreach the capabilities of such a lightweight process. Likewise, don’t try to implement a full-on waterfall style methodology either because, while definitely thorough and capable of getting the job done, it’s just overkill for many smaller projects. If you must choose a single process, pick one that’s efficient, borrows from both agile and waterfall, and is highly configurable, such as Rational Scrum or the Rational Unified Process. Both of these have the maturity to deliver large-scale projects, but also support starting small and adopting minimum ceremony.

A better awareness of what specific agile practices can and cannot accomplish is key. For example, Scrum is not a development methodology, and it cannot effectively deliver software or hardware projects unless it wraps itself around one. Yet today many organizations are employing Scrum as if it were a development methodology. I’ve even seen an organization of several hundred developers “force fed” Extreme Programming from the top down. The outcome of that particular operation: Mid-level management hid the fact that they didn’t use XP from top-level management after everyone realized what a mistake it was. Perhaps we’ll have to wait for mature standards in education and certification to evolve, but personally I’m not sitting idly by.

One of my personal pet peeves in the technology industry is a relative lack of standards and qualifications. Would you go to a doctor that didn’t have a medical degree? Would you hire an architect that didn’t have an appropriate engineering degree? Yet we hire software professionals (much less often hardware professionals) without adequate education, current qualifications, or meaningful certifications. For that matter, the proliferation of meaningless qualifications (such as Scrum Master certification) continues to weaken the industry. In the long run, we need better standards regarding education, accreditation and certification.

Understand agile methods for what they are. Keep in mind that lightweight process carries risk. Use the right tools in the right situation.

Coming full circle

If we add all of these things to agile methods, won’t we just end up using waterfall process all over again?

I don’t think so. Waterfall-based process, the original behemoth processes born out of industrial process, are widely recognized as inefficient. There are tremendous advantages to pressing forward with a merger between waterfall practices and agile practices. I hope the end result is a new generation of software and hardware development methodology — a generation that we’re just starting to see as processes such as Rational Scrum come to the fore. It’s time for development methodologies to evolve, and there’s no holding that back.

Related posts:

1. Making Scrum work: Common failings in adopting Scrum
2. Scrum is not an agile methodology
3. Common oversights in choosing methodology

1. Quality Assurance is responsible for auditing and ensuring all aspects of work meet agreed upon quality standards.
2. Therefore, if QA is also responsible for Structured Software Testing, who is going to audit the testing team for compliance and quality of deliverables?

Quality assurance is the “cop” that makes sure we all do our job right. It has the authority to say “hold it, something’s not right.” Testing is the organization that performs regression analysis on a product to see if it works right. The skills required for these two disciplines are dramatically different — as much as business management and programming.

The value in a QA organization is that it is independent. It focuses entirely on ensuring quality across the organization. Would you want development, project management, requirements management, configuration management, verification & validation, customer service or any other project discipline to report to QA? Why should testing be any different? The bottom line is simply that if testing reports to quality assurance its independence is compromised — the organization becomes vested in representing testing in the best possible light and, just possibly, taking shortcuts or letting a few things slide.

I realize that a large segment of the industry seems to use a different terminology, lumping testing under quality assurance. It’s unfortunate, because doing so handicaps both organizations. It’s important to realize the difference between the activities of ensuring quality in a project (largely focused on standards of process), and fault testing (activities that perform hands on fault detection and diagnosis).

The activities of quality assurance focus on things like quality assurance plans, project audits, requirement audits, checklists, enforcing standards and process, checking the results and deliveries of different teams, and discovering discrepancies between requirements, project artifacts, and functional goals. Quality assurance, as a general rule, spends more time looking at what the project teams are doing, performing audits on the work generated by each team, and figuring out what hasn’t been done according to agreed upon standards.

Testing, on the other hands, focuses on test planning and management, test case development, test execution, regression analysis, performance testing and defect diagnosis. These are “hands on the software” activities and much more akin to programming than auditing. Indeed, with today’s testing tools and complicated programming environments it can be a very “in the code” experience.

Keep your organization healthy and your teams focused on their competencies. Don’t disregard the value in centralizing authority for specific roles with specific teams — it lets them do their job well, without distractions and without muddying the water with conflicting interests.

Related posts:

1. Exposing the enterprise to risk: Who decides what not to test?
2. Fix your boss (or, reduce risk to quality using a matrix approach)
3. Scrum is not an agile methodology

Just as people have specializations, so do processes. Applying one process to all situations is just as wrong as calling your dentist when you need brain surgery.

Rational itself is an excellent methodology and scales very well. Starting with only a few Rational artifacts, it can almost feel like Extreme Programming. Yet, the Rational body of work provides a framework that supports a much more comprehensive methodology… something less than full-on Spiral development, but still robust enough to handle large-scale, distributed team development.

However, for all that I like Rational, it does have some holes… and these are plugged most wonderfully by Scrum. In fact, Rational and Scrum benefit each other so well I’ve started referring to the combination as “Rational Scrum.” As with most methodologies, it does not define every possible response to every possible situation, but the combination of these two techniques is very robust and complete.

The processes complete each other by addressing mutual weaknesses. Scrum steps in to fill a gap in organization and team management. Conversely, Rational brings a structured, risk-driven approach to Scrum that is lacking.

Most recently I was able to put the principles of Rational and Scrum into effect with a client. The initial engagement was, let’s say, “unfortunately typical.” The client had about 45 technical staff working in a disorganized fashion on unclear requirements. Most of the work was outsourced to a third party, further distancing the team from key business knowledge. Product releases had been very slow or nonexistent for the past year—what releases there were had been seriously compromised in quality. Development felt isolated from the business and quality assurance was a poorly funded afterthought. The production support group of about five people were out of the loop on software deliveries and constantly scrambling to stay on top of customer driven emergencies.

My first task was to get my mind around what was going on. I took a trip to the outsource vendor (amazingly, this was the first trip anyone from the company had taken to the vendor) to get to know the team. I spent several weeks understanding the issues and bringing the team up to speed on what the business was really all about. Because of time differences (about thirteen hours) this sort of cross-pollination had never happened. Ideally, I would have set up a program where the entire team would have rotated through on-site “shifts” of several weeks duration, but budget was limited. This would have created a far more integrated team and given each person on-the-ground experience with the business, its goals, its priorities. I also delivered some training on Rational methodology in a compressed one-week course to the entire development team.

One of the most glaring problems was a complete lack of information share between the business and the development teams. We immediately purchased and implemented task and defect tracking (with Atlassian Jira) and a document repository (with Atlassian Confluence). Effective immediately, all information had to be migrated to the new system. If it wasn’t in there, it didn’t exist. I went so far as to return, unread, any technical email or document I received unless it was in Jira or Confluence. Absolutely no defect, feature request or deliverable could be discussed until it was put into Jira, given a once over to make sure the issue was stated clearly and, in most cases, given a quick first-pass effort estimate from development.

We also started having daily Scrums. This proved to be the most difficult challenge—the time difference pretty well necessitated a tight meeting window. Once back in the U.S., I ended up scheduling nightly telephone calls with the development teams from 8:00 PM until about 11:00 PM every day. This went on for months, but was necessary to drive improvement. We typically kicked off an evening with the “management Scrum,” limiting it to no more than half an hour (I doubled the time limit because it was virtual, organization was difficult, and at least initially there were a lot of issues to work through). Once the management Scrum wrapped up, splinter Scrums started up with each of the individual development, quality assurance, testing and professional services teams. Even following Scrum guidelines to keep the meetings on-track, we initially ended up with plenty of overflow. This was followed with a management Scrum on U.S. timetables, the following morning. Initially, it was a grueling meeting schedule for me, but we kept individual team member involvement to a minimum—preferably one daily Scrum.

Another major change was implementing the Rational Unified Process. This took upwards of six months to effect as we introduced light processes initially, adding to the Rational methodology over time. A few of the most important aspects of Rational that we adopted early on were risk-driven development and truly iterative releases. While development had been using iterative terminology, the fact of the matter is that monolithic development practice was still being followed (for example, creating massive specifications and trying to build to the specifications rather than focusing on short-term release goals and continuous improvement). By focusing the team on short-term releases, iterative release cycles and a product backlog (all done in Jira and Confluence) we quickly raised the level of understanding, across the board, of what was coming and what it would take to deliver. This information started to flow throughout the organization and we started to see its effects in how product features were prioritized, how releases where scheduled, and in customer service and the product life cycle itself. Soon, the company went from half a dozen silos of locked away information to a single, relatively smoothly operating organization with across-the-board visibility.

During this evolutionary phase of these changes we discovered all kinds of interesting things were going on. We found separate development teams working on the same foundation technology. Optimizations that could be made with small shifts in the business goals. Streamlining and efficiency gains by changing our release cycle. Massive effort savings by disregarding a few relatively unimportant features. More streamlining that came from the information sharing. The product backlog started to become self-prioritizing as business owners and other stakeholders participated in setting the upcoming release goals. Distractions, fire-fighting, context-switching and misdirection disappeared and the development team started producing true forward progress for the first time in a couple of years.

In fact, the team went from essentially zero forward progress to a steady, major new software release every six months.

We also trimmed operational costs by about $1.2 million dollars per year. Of the 45 outsourced development staff originally on the project, we reduced the count to fifteen in less than a year. And they still kept producing a major new software release every six months. Despite a team size of about one third, we were delivering more and getting more done in less time.

We implemented improved quality assurance measures and actually increased the size of the software testing team from one person to three (all within the 15 person head-count). Software quality started to improve at a dramatic rate.

Through Rational Scrum we had realized a productivity increase of somewhere in the vicinity of 300-400% if we account for the team size reduction. We had achieved positive forward progress where it had been lacking for well over a year, if not two, and had done so after cutting the development team down to one third of its original size.

Toward the tail end of my involvement, after about 18 months on the project, the team size had been scaled back a bit more. The daily Scrum meetings had become smooth and unintrusive, going from two or three hours down to about 15-20 minutes per team. New technology teams focusing on completely new product lines were being hired and integrated into the process very effectively. Even the professional services group had adopted the process and, likewise, had reduced its staffing requirements from five to two and was operating more smoothly. Customer satisfaction was up and the fire-fighting had pretty well come to a stop.

The two processes—Rational Unified Process and Scrum—gave the company the focus and clarity it need to get back on track. Working together, these processes had delivered improvement to every aspect of the organization:

1. All stakeholders in the project become a part of the development process. Everyone involved is genuinely interested in the project output and actively contributing torward progress.
2. Visibility is raised across the board through information sharing. This improves efficiency, mindshare and contributes to progress as well. The group contribution is far more valuable than individual “information silos.”
3. Truly iterative development delivers working, progressively improving software rapidly. Incremental change is easily accommodated by avoiding the “big bang” and monolithic development approach.
4. Rational’s focus on risk-driven development keeps the team focused on the most difficult, potentially risky aspects of the project first. This contributes on a number of fronts: Major problems stemming from unknowns become identified and are dealt with early in the project. Major change stemming from these unknowns has less impact because it happens early. The riskiest, most complex portions of the project are developed first, and thus mature first and receive the most testing.
5. Risk analysis and mitigation “bubbles to the top” through the daily Scrum meetings.
6. Priorities come in-line with business and technical reality as the whole team works on sensible, informed schedules.
7. Ownership and accountability become the mainstay as everyone develops a long-term interest in the project and pride of work product in their contribution. Commitments are taken seriously as a team.
8. Visibility into the entire process means there are no surprises and no last minute bad news. The business can plan according to reality and influence the overall program in an informed manner.
9. Progress is realized for effort and planning, not for putting “hours in the cubicle.” People are rewarded for good work and not for punching a clock.
10. Quality becomes integral and continuous. The Rational process integrates quality assurance and structured testing from the very beginning of the project. It is never an afterthought.

Rational Scrum delivers a solution for small-scale as well as large-scale project development. It supports the essential aspects of project and program management that make quality software development a possibility. It adds the dimensions of reliability and repeatability to projects and focuses the team on continuous improvement and productive work.

Related posts:

1. Making Scrum work: Common failings in adopting Scrum
2. Why Agile isn’t enough (and why it doesn’t work)
3. Scrum is not an agile methodology