Theories for Agile Management

THE THEORY OF CONSTRAINTS

The Theory of Constraints (TOC) was introduced in 1984 in Eli Goldratt's business novel, The Goal. Initially unavailable in stores, Goldratt described the book as a marketing brochure for his consulting business. It was later available in book stores and sold over 2 million copies. Described as a love story, The Goal follows Alex Rogo on his personal journey as he gradually turns around his ailing and unprofitable manufacturing plant. Facing closure of his plant, and the breakup of his marriage, everything seems to be going wrong. Then he meets Jonah. Jonah is a master in the application of the Theory of Constraints, and he coaches Alex to better understand how his own manufacturing plant works.

TOC, applied to manufacturing, seeks to identify bottlenecks in the production line. The underlying assumption is that a production facility is only as fast as the slowest process in the chain. As a general rule, TOC assumes that a value chain is only as strong as the weakest link in the chain. The capacity of the weakest link is the current system constraint.

TOC improves manufacturing profitability by first identifying the constraint, then maximizing the exploitation of the constraint. The rate of throughput on the constraint—the capacity of that process stage or machine—is used to regulate the throughput of the whole assembly line or system. New material is only introduced into the system at the rate that it can be consumed by

the bottleneck. In TOC, this technique is known as Drum-Buffer-Rope. (It is fully explained in Chapter 3.) Applying this basic TOC principle to a manufacturing plant has the effect of reducing the inventory of material throughout the system.

JUST-IN-TIME INVENTORY

In the early 1980s, another theory—this one from Japan—was also catching on in western manufacturing. The Japanese were at that time significantly outperforming their western competitors. Their products were often cheaper and better. One of the most successful Japanese companies was Toyota. It used the Toyota Production System, or Kanban Approach, devised by Taiichi Ohno [Ohno 1988]. This system sought to minimize inventory in the factory and ensure that required inventory was delivered to the point where it would be consumed, just before it was needed. Ohno had based the technique on methods used by American grocery store chains, which he had observed stacking shelves on an as-needed basis, just as consumers were ready to buy products. Generically, Ohno's technique was known as just-in-time (JIT) manufacturing.

Chapter 2 shows that reduction of inventory and of the sums invested in the inventory have a significant effect on the profitability of a manufacturing business. Hence, reducing inventory through use of JIT was one critical way to compete with the Japanese. Reduced inventory was also seen in the early 1980s as a side effect of TOC's focus on bottlenecks. There was little association between TOC and JIT in the published literature.

Reducing inventory reduces the level of investment. The Return on Investment (ROI) for a plant practicing JIT, or inventory control from TOC's Drum-Buffer-Rope, will increase. Japanese manufacturers were thus enjoying significantly better ROI than their western competitors during much of the 1960s, 1970s, and 1980s.

1 This Throughput Accounting definition of ROI will be explained in Chapter 2.

Western competitors had assumed that Asian firms simply had lower labor rates and failed to fully comprehend the competitive advantage of lower inventory levels. As reducing inventory also reduced the financing charges and the cost of storage space, the Operating Expense (OE) was lower, too. Reducing operating expense increases profitability. In industries where margins are tight, these small variations can mean the difference between profit or loss.

2 Throughput Accounting definition for Net Profit.

QUALITY

The Japanese had also realized that better quality was important. They learned the importance of quality assurance (QA) from the American statistician Edwards Deming. Deming had visited Japan in the 1950s and taught Statistical Process Control (SPC) theory, specifically how to interpret the control charts of Walter Shewhart [Wheeler 1992]. Control charts show whether a process is under control. Control is defined by whether or not the output is within the acceptable tolerance for the specification. If something is within specification, it is of good quality. Hence, adoption of SPC led the Japanese to focus on product quality. As explained in Chapter 9, improved quality improves the throughput of a system. Hence, the Japanese were enjoying improved profitability from quality assurance, as well as improved ROI from just-in-time inventory control.

Another theory that caught on in the west in the early 1980s was Total Quality Management (TQM). It sought to bring repeatability, control, and predictability to manufacturing through traceability. TQM espoused the notion that manufacturing could be more efficient (read “profitable”) if quality were improved. Quality could be improved through improved traceability, which would provide audit trail information for verification and validation of quality. TQM gave

rise to ISO-9000, Tick-IT, and other quality-related initiatives. TQM used a mental model in which the upstream process was the “supplier” and the downstream process the “customer.” Everyone had an “internal customer” for their work. TQM was based on the notion that locally optimal quality would lead to a global optima. It was not based on the ideas of systems thinking.1 However, it did have a positive effect on many organizations. As quality improved, so did throughput and, consequently, profitability.1 O'Connor, Joseph & McDermott, lan, The Art of Systems Thinking: Essential Skills for Creativity and Problem Solving Thorsons, San Francisco, California 1997.

Quality improves production because it reduces rework. Rework means less waste, less OE, and a higher Production Rate (R). Assuming sales is not a constraint and all increases in production lead to increases in sales, it can be shown that investment in quality pays for itself. Increased Throughput (from sales) leads directly to higher profits and better return on investment:

LEAN PRODUCTION

In the late 1980s, western industrialists recognized that JIT and QA had related parts to play in the overall improvement of the manufacturing industry. The term “Lean” was first coined by Womack and colleagues in their book, The Machine That Changed the World, which documented the superior ability of the Japanese automobile manufacturing processes in comparison to western mass production pioneered by Henry Ford at Ford and Alfred Sloan at General Motors [Womack 1991]. What Womack and colleagues were actually documenting was the combination of Ohno and Shingo's [Shingo 1989] low inventory, just-in-time system with Deming's quality system. In Japan it is known as the Toyota Production System (or the Kanban System) and, more recently, “The Toyota Way,” because Toyota has recognized that

the management method can be applied to more than just production.

Table 1-1. Management theory and its focus areas.

SIX SIGMA

Six Sigma is a quality-related term that specifically refers to a defect level of less than four per million. This level is considered in many industries to represent perfection. However, the term has grown in meaning to define a management method for implementing manufacturing systems that lead to improved quality and focused investment to eliminate errors. It is most notably associated with General Electric and Motorola.

Six Sigma as a process focuses on two areas: quality assurance and reduction of variance. It takes the position that it is better to have defects with a repeatable pattern (a low variance) than defects with a random pattern. The assumption is that defects that repeat probably have a common cause. If the common cause can be found, the defect can be removed with a single change or investment. Hence, improved quality is achieved through reduction of variance.

COMPARISON OF THEORIES

It is now recognized that all these theories—JIT, QA, TQM, Lean, Six Sigma, and TOC—are related. They represent best practices for running a process, system, or value chain. TOC originally focused on bottlenecks. JIT originally focused on reduction of inventory. TQM and SPC were focused on quality and conformance to specification. The concept of Lean is the effective

combination of all of them. Six Sigma also focuses on quality and can be seen as complementary to Lean as shown in Table 1-1.

The effect of these theories on the manufacturing industry has produced an immense economic improvement for society. Nowadays, the public expects exceptional quality from consumer products. Very low prices are expected for amazingly complex technical products, such as DVD players. When, for example, was the last time you saw someone take the trouble to repair a broken coffee maker or iron? It simply isn't worth it. A new one can be purchased for less than $20. Economic gains such as these have been possible through application of Lean Thinking [Womack 1996] in manufacturing.

Has Improved Profitability Been the Only Benefit?

Manufacturers will tell you that their business gets more competitive every year. In the last 30 years, competition has gone off the scale and productivity improvements of up to 30 times were common. The truth is TOC, JIT, TQM, SPC, and Six Sigma have done more than just improved profitability. These theories have improved overall competitiveness. That means that manufacturing is now more flexible and faster to react to market conditions. This has been achieved through reduced inventory, reduced lead time, better visibility into inventory levels, better understanding of the processes at work, and better understanding of how to exploit system elements and processes.

In summary, the application of TOC, Lean, SPC, JIT, or TQM has improved the agility of the manufacturing industry. Lean manufacturers are agile manufacturers. Manufacturers who best exploit their capacity constrained resources are agile manufacturers. Manufacturers with better quality assurance systems are agile manufacturers.

With the financial metrics presented in Chapter 2, it can be shown that agility and profitability go hand in hand. In the manufacturing industry, agile processes are better for business. Could this also be true in the software business?

Mary Poppendieck has shown in her work on Lean Programming that the theories of JIT and TQM can be applied to software development [2001]. Poppendieck has suggested that Agile software development methods such as Scrum share common principles with Lean Manufacturing. Others in the Agile community, including Beck & Fowler [Beck 2002a/2002b], have observed that Agile methodologists have a lot to learn from Taiichi Ohno's Kanban approach.

THREE PHASES OF SCIENTIFIC DEVELOPMENT

Eli Goldratt has suggested that the sciences evolve in three distinct phases—classification, correlation, and effect-cause-effect [Goldratt 1990].

Phase 1—Classification

Classification is the phase in which nomenclature is debated and then agreed upon. People discuss what exactly is involved in the field they are pursuing or studying. They then agree on the names for founding elements or principles. The current state of Agile methods for software development would suggest that several of them have an agreed internal nomenclature. This is certainly true of XP, Scrum, and FDD. However, the nomenclature may not yet be complete. Initiatives such as Scott Ambler's Agile Modeling suggest that more nomenclature may be necessary [2002]. There is certainly no agreement across Agile methods on a combined or unified nomenclature. Agile methods as a combined science can be considered to be in the classification stage.

Phase 2—Correlation

Correlation is Goldratt's term for the phase in which corroborating evidence is available to show that a method works in practice. Correlation is a phase of pattern recognition. The science of astronomy, when it was still known as astrology, spent thousands of years in the correlation stage. It was possible for astrologers to predict astrological events such as the turning of

the year, the rise of the planets in the sky, and so forth by pattern matching against observations of recurring patterns.

It could be argued that the science of Object Oriented Analysis has reached the correlation stage. The classification stage ended with an agreement on the Unified Modeling Language—the nomenclature of OO Analysis and Design. The correlation stage actually started prior to this, with the emergence of patterns in the early 1990s. The correlation phase is now in full swing. A considerable body of work is available on OO Analysis. Books which have broken new ground include Analysis Patterns [Fowler 1997], Object Models [Coad 1996], JAVA Modeling in Color with UML [Coad 1999], and Streamlined Object Modeling [Nicola 2001]. Similar work has been published in the field of OO Design by a long list of authors, notably Design Patterns [Gamma 1995] and Java Design [Coad 1997]. Others seek to teach the theory in a more palatable form, for example, Applying UML and Patterns Larman [2001].

Individually, then, some Agile methods have entered the correlation phase. That is to say that there is “proof in the pudding.” There is corroborating evidence that the techniques work. People from all around the world have run XP, Scrum, and FDD projects and have reported better results. I personally have run (or been involved with) more than 10 FDD projects, and the results are remarkably similar across all of them. This similarity has been true across four geographical locations, with four different teams, each with different cultural, educational, and personal backgrounds, and irrespective of technology or industry involved. Evidence that shows a method or theory to be true in practice means the method or theory is in the correlation stage.

Phase 3—Effect-Cause-Effect

The third and final stage in the emergence of a science is effect-cause-effect. Astronomy became a science after Isaac Newton proved why apples fall down, rather than sideways. This effect was explained through its cause—gravity. The theory was then used to predict another effect—the Earth's orbit of the sun. When

it is possible to postulate a theory, measure the effect, and validate the theory, science is being practiced.

If the art of managing software development is to be developed into a science, agreement must be reached on what is to be measured and what those measurements are called. How one measurement affects another must be understood. This would then permit managers to predict the effect of a decision on a new situation based on what is already known.

Many aspects of software development can be correlated against aspects of the manufacturing industry. Within manufacturing, many effect-cause-effect relationships are understood. Manufacturing has grown into a science over the last 30 years. By translating cause-effect relationships from manufacturing to software development, it should be possible to predict the effect. If the effect can be measured and validates the accuracy of the prediction, then software development management will have evolved into a science.

SCIENTIFIC PROOF FOR AGILE MANAGEMENT

If, for example, the suggestion made in Chapter 2 that ideas can be treated as the inventory in a system of software production is acceptable, then it could be predicted, based on the cause-effect relationship observed in manufacturing, that reducing inventory will improve overall profitability. This is something that can be easily measured.

First, the existing organization must be measured to determine a baseline for the experiment. The current inventory level must be established, along with the production rate. It may be necessary to correlate the existing results against an expectation for the new Agile method to be introduced, that is, map Use Cases to Stories or Function Points to Features. The chosen Agile method should be introduced under controlled circumstances. The results should be measured. If the prediction is correct, a reduction in inventory and an increase in production rate should be observed. If so, there is scientific proof that Agile methods really are better for business.

EMPIRICAL VERSUS DEFINED PROCESSES

There has been considerable debate amongst Agile methodologists since Schwaber and Beedle published their book describing the Scrum method. Schwaber observed that traditional software development methods were like defined process control mechanisms and argued that this was the root cause of today's problems with traditional methods [2002, pp. 24–25]. What was required instead was an empirical method, which all Agile methods were. This made them better.

Webster's dictionary defines empirical as “Depending upon experience or observation alone, without due regard to science and theory.” In other words, there is no underlying scientific theory that explains the observed phenomena. Control and prediction are based purely on observation of a pattern. To use Goldratt's terminology, the notion of empirical measurement relates to the correlation phase of a science. When it is possible to observe a pattern but not to explain it, then it may be possible to base measurements around observation of the pattern repeating. Astrology, the predecessor of Astronomy, was based purely on empirical measure. Empirical measure gave us the 7-day week and the 365-day year long before Isaac Newton explained why it takes the Earth 365 days to orbit the sun.

Defined measurement, on the other hand, is based on the concept of a known cause-effect relationship. Defined measurement allows a prediction of how long a ball bearing will take to hit the floor after it rolls off a table.

In an interview with Jim Highsmith [Highsmith 2002, p. 242], Schwaber extends his discussion to state that all empirical processes are “chaordic,” a term which contains the notion that all software development lives on the edge of chaos. The debate surrounding Agile methods has polarized into one of chaordic versus defined processes—Agile versus traditional methods. The Agilists use the chaordic nature of software development to argue that there is no point in planning software development or trying to predict it. Rather, the only course of action is to observe it and report the results.

This notion is abhorrent to most senior executives of large companies. The notion that a major area of cost—software development—should be allowed to run without planning or defined goals is unlikely to curry favor in the boardroom.

However, I do not subscribe to the assumption that software development is always chaordic and lives on the edge of chaos. Chapter 32 will discuss Wheeler [1992] who has classified four types of process control—one of which is called the “edge of chaos.” Software development can exist within each of his four categories. Further, it is not automatically true that empirical processes are chaotic or tend towards chaos. An empirical process may be a convergent process. Its convergence may have been observed through empirical measure, but may not have been explained by science. Hence, an empirical process can produce results with an accuracy normally expected from a defined process, but without the scientific explanation of why. The sun, for example, rises every morning, but for many thousands of years, this regularity was unexplained. As a result, superstitions and religious beliefs were based on the miracle that the sun didn't tend toward chaos, and the sky didn't lie dark for years.

CONVERGENT VERSUS DIVERGENT PROCESSES

It may be more important to understand not whether a process is empirical or defined, but whether it is convergent or divergent. Convergent implies that under some form of control a process will converge over time on a predictable solution. This applies to both empirical and defined processes. For example, one developer I spoke to said, “In my experience, a good Extreme Programming team becomes adept at assessing their velocity and predicting what they can deliver in a single, 2-week iteration.” This would suggest that Extreme Programming is a convergent process.

Divergent processes are processes that refuse to converge under control and consistently produce inconsistent results. In control theory, divergence is usually described as chaotic or out-of-control behavior. Specifically, a process is described as being

“outside the envelope” (of control). When a process is not under control and not capable of being brought under control, it is a divergent process.

CHAOS THEORY AND UNCERTAINTY

In the last 20 years, a whole new branch of science has emerged based on chaos theory. For the previous 300 years, science had been grounded in the theories of the mathematician Renee Descartes [1625] who suggested that everything could be gradually decomposed until such time as it was divisible no further and at this point it would be possible to scientifically explain its behavior and composition. Its corollary held that something that was not understood simply had not been sufficiently decomposed.

The principles of Descartes suggest that eventually everything is convergent when it is properly understood—alchemy becomes chemistry, astrology becomes astronomy. Science has taught us to believe that all things converge and do so to a singularity. For example, there is only one precise answer to the time it takes the Earth to orbit the sun. However, study of weather patterns has shown that there are things that do not converge on a singularity. No matter how many weather sensors are added to a weather prediction system, the accuracy will only ever be so good. Adding more sensors does not improve it further. This does not mean that the science of meteorology is divergent. It means that it does not converge on a singularity, rather it converges on an approximation—a value with a measure of uncertainty.

The principle of uncertainty has been known in physics for some time, having been postulated by the nuclear physicist Hiesenberg. The science of physics learned to live with uncertainty. The Theory of Constraints teaches the business systems methodologist how to live with uncertainty in other fields, such as production, project management, and enterprise resource planning.

Philosophically, an effect that is known to involve uncertainty is not necessarily divergent or uncontrollable. It is merely

convergent on an approximation. It does not mean that something that is uncertain cannot be classified, codified, measured, or controlled. It simply means that our measurements must always reflect a degree of uncertainty.

Hence, this text is grounded in a basic assumption that planning and prediction are possible within some bounds of uncertainty. Financial predictions for the performance of a software development business are possible, but must always be couched with a degree of tolerance. Agile management is all about being able to cope with uncertainty.

SYSTEMS THINKING AND LEARNING ORGANIZATIONS

Peter Senge has called systems thinking the “Fifth Discipline” [1990]. He believes that the ability of an organization to understand what it does as a holistic system is the first step in becoming a learning organization. A learning organization is one that constantly improves its competitiveness because it understands what it does and how it actually does it. Software development can be seen as a complex adaptive system. All such systems have feedback loops. Feedback provides the opportunity for improvement. Senge calls this “learning.” Feedback is necessary for learning.

EMERGENCE

In recent years, science has discovered phenomena that are described as “emergent.” This has spawned the new science of Complex Adaptive Systems. Chapter 2 will show that complex systems with feedback loops produce adaptive behavior and exhibit emergent properties. Simple rules govern the internal behavior of the system, which results in the externally observed adaptive behavior. Hence, systems thinking, control theory, and emergence are all related. The study of Complex Adaptive Systems tries to understand what the simple rules are that produce often amazing results. Simple rules are what inspire ants to build great anthills and to work as a team to perform tasks that ought not to be possible for such basic creatures.

It has been observed by Agile methodologists that software development is a complex adaptive system, that produces adaptive behavior—working code—and exhibits emergent properties—foosball tables in basements and on-line bug databases.

The argument has been made that if software development is emergent and the outcome is by the nature of adaptive systems unpredictable and uncertain, then software development cannot be planned or predicted. Therefore, software development should not be planned, but should emerge based on last-minute decisions on what to do next.

This notion is suggested in the Agile Manifesto principle, “The best architectures, requirements, and designs emerge from self-organizing teams.” The notion of self-organization implies emergence. The argument follows that adaptive systems imply an unknowable outcome. Hence, planning is futile.

Again, among those interested in running a business for profit, the notion that planning and control are impossible is a little daunting. The thesis of this book is that software is not divergent and can be planned and controlled. The proper jobs of executives are to set the goal for the adaptive behavior of the system and to select the method with which the goal is measured and the system feedback delivered. In addition, they may need to create an environment within which the complex adaptive system of software development can exist freely to self-organize at the appropriate level.

The tasks for each manager at each level in the hierarchy of a software development organization are to define the desired output from the part of the system under his or her control, to define the rules for measuring that system, and to create the conditions for the system to operate freely and then to keep out of the way, allow it to self-organize based on feedback, and produce the desired results.

What is important is that those setting the rules set rules that reflect the nature of the system holistically, which leads to

delivery of global optima rather than local efficiencies. With the correct rules, the performance of a system is predictable within a degree of uncertainty. For example, it is predictable that a nest of ants will build an anthill. The size of the anthill and the area it will cover can be predicted with some certainty, based on knowledge of the type of ants and the population. What cannot be predicted is the precise shape, the precise time of completion, or the necessary level of effort. Nevertheless, predicting the growth of an anthill is like predicting the weather, it can be done with a degree of accuracy. It is not chaotic.

SUMMARY

Agile management must cope with uncertainty and deliver better business results. To do this, it must incorporate techniques from TOC, JIT, TPS, TQM, QA, Six Sigma, and Lean Production. Specifically, agility is delivered through a focus on quality assurance, reduction of inventory, identification and investment in bottlenecks to increase production, and reduction in variance, which improves estimation and quality assurance.

Agile software development methods are methods of empirical control for software production management. Empirical methods are not necessarily chaotic and can be planned and estimated. The design of a software development method must be such that the method converges and produces repeatable results as often as possible.

Agile software development methods are complex adaptive systems that exhibit emergent properties and adaptive behavior. The desired adaptive behavior from an agile system of software production is working code valued by the customer.

Agile Software DevelopmentAgile is a time-bound, iterative approach to software delivery that builds software incrementally from the start of the project, instead of trying to deliver all at once.

Why Agile?Technology in this current era is progressing faster than ever, enforcing the global software companies to work in a fast-paced changing environment. Because these

businesses are operating in an ever-changing environment, it is impossible to gather a complete and exhaustive set of software requirements. Without these requirements, it becomes practically hard for any conventional software model to work.The conventional software models such as Waterfall Model that depends on completely specifying the requirements, designing, and testing the system are not geared towards rapid software development. As a consequence, a conventional software development model fails to deliver the required product.This is where the agile software development comes to the rescue. It was specially designed to curate the needs of the rapidly changing environment by embracing the idea of incremental development and develop the actual final product.Let’s now read about the on which the Agile has laid its foundation:Principles:

1. Highest priority is to satisfy the customer through early and continuous delivery of valuable software.

2. It welcomes changing requirements, even late in development.3. Deliver working software frequently, from a couple of weeks to a couple of months,

with a preference to the shortest timescale.4. Build projects around motivated individuals. Give them the environment and the

support they need, and trust them to get the job done.5. Working software is the primary measure of progress.6. Simplicity the art of maximizing the amount of work not done is essential.7. The most efficient and effective method of conveying information to and within a

development team is face-to-face conversation.Development in Agile: Let’s see a brief overview of how development occurs in Agile philosophy.

In Agile development, Design and Implementation are considered to be the central activities in the software process.

Design and Implementation phase also incorporate other activities such as requirements elicitation and testing into it.

In an agile approach, iteration occurs across activities. Therefore, the requirements and the design are developed together, rather than separately.

The allocation of requirements and the design planning and development as executed in a series of increments. In contrast with the conventional model, where requirements gathering needs to be completed in order to proceed to the design and development phase, it gives Agile development an extra level of flexibility.

An agile process focuses more on code development rather than documentation.Example: Let’s go through an example to understand clearly about how agile actually works.A Software company named ABC wants to make a new web browser for the latest release of its operating system. The deadline for the task is 10 months. The company’s head assigned two teams named Team A and Team B for this task. In order to motivate the teams, the company head says that the first team to develop the browser would be given a salary hike and a one week full sponsored travel plan. With the dreams of their

wild travel fantasies, the two teams set out on the journey of the web browser. The team A decided to play by the book and decided to choose the Waterfall model for the development. Team B after a heavy discussion decided to take a leap of faith and choose Agile as their development model.The Development plan of the Team A is as follows:

Requirement analysis and Gathering – 1.5 Months Design of System – 2 Months Coding phase – 4 Months System Integration and Testing – 2 Months User Acceptance Testing – 5 Weeks

The Development plan for the Team B is as follows:

Since this was an Agile, the project was broken up into several iterations. The iterations are all of the same time duration. At the end of each iteration, a working product with a new feature has to be

delivered. Instead of Spending 1.5 months on requirements gathering, They will decide the

core features that are required in the product and decide which of these features can be developed in the first iteration.

Any remaining features that cannot be delivered in the first iteration will be delivered in the next subsequent iteration, based in the priority

At the end of the first iterations, the team will deliver a working software with the core basic features.

Both the team have put their best efforts to get the product to a complete stage. But then out of blue due to the rapidly changing environment, the company’s head come up with an entirely new set of features and want to be implemented as quickly as possible and wanted to push out a working model in 2 days. Team A was now in a fix, they were still in their design phase and did not yet started coding and they had no working model to display. And moreover, it was practically impossible for them to implement new features since waterfall model there is not reverting back to the old phase once you proceed to the next stage, that means they would have to start from the square one again. That would incur them heavy cost and a lot of overtime. Team B was ahead of Team A in a lot of aspects, all thanks to Agile Development. They also had the working product with most of the core requirement since the first increment. And it was a piece of cake for them to add the new requirements. All they had to do is schedule these requirements for the next increment and then implement them.

Advantages: Deployment of software is quicker and thus helps in increasing the trust of the

customer. Can better adapt to rapidly changing requirements and respond faster. Helps in getting immediate feedback which can be used to improve the software in

the next increment. People – Not Process. People and interactions are given a higher priority rather

than process and tools. Continuous attention to technical excellence and good design.

Disadvantages:

In case of large software projects, it is difficult to assess the effort required at the initial stages of the software development life cycle.

The Agile Development is more code focused and produces less documentation. Agile development is heavily depended on the inputs of the customer. If the

customer has ambiguity in his vision of the final outcome, it is highly likely for the project to get off track.

Face to Face communication is harder in large-scale organizations. Only senior programmers are capable of taking the kind of decisions required

during the development process. Hence it’s a difficult situation for new programmers to adapt to the environment.

Agile is a framework which defines how the software development needs to be carried on. Agile is not a single method, it represents the various collection of methods and practices that follow the value statements provided in the manifesto. Agile methods and practices do not promise to solve every problem present in the software industry (No Software model ever can). But they sure help to establish a culture and environment where solutions emerge.

Traditional Development ModelThe traditional approach to software development includes Waterfall model. Waterfall Model is the oldest form of software development model that offers the various stages through which the cycle of software development has to go.

The very essence of a traditional software development life cycle lies in the following few facts:

The aim is to understand from a user's perspective as to what their requirements are, design a robust structure that shall help in delivering the right product, flawlessly.

Planning risk management tasks.

The traditional model emphasises on finding alternative solutions towards attaining the desired objective, that is, choosing the best alternate among the available list of alternatives.

Such a model relies on the fact that there is an optimal solution available for a problem, as a given problem is considered to be well-defined.

It assumes that the processes are predictable and are repetitive.

The model believes that the processes are measurable and any variations in the processes can be controlled and during the development life cycle.

Based on understanding of systems development, an organisation follows a certain kind of management style.

A hierarchy is maintained, therefore assuring a stability across the various levels.

An environment of formalisation and standardisation in created. People with specialisation in different roles are assigned tasks which they are expected to accomplish, to produce the desired outcome.

Customers play an active role, mostly during the specification and implementation stages.

Agile ModelAgile methods took over the traditional methods, to overcome the rigidity of the traditional model. Agile follows a dynamic approach

to software development. It is an interactive and team based method that aims to deliver an application in a short span of time.

In agile methodology, tasks are categorised into phases and are ''time-boxed'', that is, time frames are allotted to each task. Each time-boxed phrase is called a sprint. Each sprint has a defined duration of time, say, a week, few days or month.

A detailed description of how the agile model helps to overcome the shortcomings of the traditional model.

Agile is based on empirical process, which provides a control mechanism based on a defined set of methods. Empirical method is meant for those processes that are not very well defined, unpredictable or unrepeatable. Agile technique implements control through frequent inspection and adaptation.

It is a dynamic approach to software development. That is, this technique is quick in adapting to changes as requested by the user.

It has brief iterative life cycles, which reflects periodic changes, and thus integrating small change cycle to the overall system development process.

Involves communication with customers consistently, taking their feedback as input, during the different iterative cycles.

Agile Vs TraditionalSNo.

Traditional Model Agile Model

1. Follows a top down approach, and making changes is not easy as finishing one phase leads to another

Team conducts experiments on various techniques and gradually arrives at the best possible solution

2. It has a leadership style of working

In agile, there is free flow of communication, anyone can present their ideas within the team

3. Pre-planning is done to carry out the various phases

This is more flexible as compared to traditional model, as it can change it's work flow based on any new request for modifications

4. Customer is involved only in the initial phases of requirements gathering

Customer involvement is crucial for this model to prove its mettle

5. The project plan is prepared before commencing the process of system development

Project work is delivered to the client in small amount, that is, as and when one module is prepared, a demonstration is given to the client, so as to confirm the

work progress in a right direction

6. The ownership lies on the Project manager

It has the concept of shared ownership, i.e, every team member is equally responsible for their individual contribution

7. Believes in one-time delivery of the product

Relies on incremental delivery of the product

Conclusion:

Both agile and traditional models are essential for an efficient software development process. However, in the process of choosing an appropriate model for software development, one needs to identify the scope and requirements of the project to be developed. Accordingly, a model is chosen that helps to deliver the right things at the right time.

Agile Model does overcome few deficiencies that the traditional model imbibes, but at the same time each model's pros and cons must be weighed before reaching a consensus.

What Is Agile Methodology?The various agile Scrum methodologies share much of the same philosophy, as well as many of the same characteristics and practices. But from an implementation standpoint, each has its own recipe of practices, terminology, and tactics. Here we have summarized a few of the main agile software development methodology contenders:

Agile Scrum MethodologyScrum is a lightweight agile project management framework with broad applicability for managing and controlling iterative and incremental projects of all types. Ken Schwaber, Mike Beedle, Jeff Sutherland and others have contributed significantly to the evolution of Scrum over the last decade. Scrum has garnered increasing popularity in the agile software development community due to its simplicity, proven productivity, and ability to act as a wrapper for various engineering practices promoted by other agile methodologies. With Scrum methodology, the "Product Owner" works closely with the team to identify and prioritize system functionality in form of a "Product Backlog". The Product Backlog consists of features, bug fixes, non-functional requirements, etc. - whatever needs to be done in order to successfully deliver a working software system. With priorities driven by the Product Owner, cross-functional teams estimate and sign-up to deliver "potentially shippable increments" of software during successive Sprints, typically lasting 30 days. Once a Sprint's Product Backlog is committed, no additional functionality can be added to the Sprint except by the team. Once a Sprint has been delivered, the Product Backlog is analyzed and reprioritized, if necessary, and the next set of functionality is selected for the next Sprint. Scrum methodology has been proven to scale to multiple teams across very large organizations with 800+ people. See how VersionOne supports Scrum Sprint Planning by making it easier to manage your Product Backlog.

Lean and Kanban Software DevelopmentLean Software Development is an iterative agile methodology originally developed by Mary and Tom Poppendieck. Lean Software Development owes much of its principles and practices to the Lean Enterprise movement, and the practices of companies like Toyota. Lean Software Development focuses the team on delivering Value to the customer, and on the efficiency of the "Value Stream," the mechanisms that deliver that Value. The main principles of Lean methodology include:

Eliminating Waste

Amplifying Learning

Deciding as Late as Possible

Delivering as Fast as Possible

Empowering the Team

Building Integrity In

Seeing the Whole

Lean methodology eliminates waste through such practices as selecting only the truly valuable features for a system, prioritizing those selected, and delivering them in small batches. It emphasizes the speed and efficiency of development workflow, and relies on rapid and reliable feedback between programmers and customers. Lean uses the idea of work product being "pulled" via customer request. It focuses decision-making authority and ability on individuals and small teams, since research shows this to be faster and more efficient than hierarchical flow of control. Lean also concentrates on the efficiency of the use of team resources, trying to ensure that everyone is productive as much of the time as possible. It concentrates on

concurrent work and the fewest possible intra-team workflow dependencies. Lean also strongly recommends that automated unit tests be written at the same time the code is written. The Kanban Method is used by organizations to manage the creation of products with an emphasis on continual delivery while not overburdening the development team. Like Scrum, Kanban is a process designed to help teams work together more effectively.

Kanban is based on 3 basic principles:

Visualize what you do today (workflow): seeing all the items in

context of each other can be very informative

Limit the amount of work in progress (WIP): this helps balance the

flow-based approach so teams don 't start and commit to too much

work at once

Enhance flow: when something is finished, the next highest thing

from the backlog is pulled into play

Kanban promotes continuous collaboration and encourages active, ongoing learning and improving by defining the best possible team workflow. See how VersionOne supports Kanban software development.

Extreme Programming (XP)XP, originally described by Kent Beck, has emerged as one of the most popular and controversial agile methodologies. XP is a disciplined approach to delivering high-quality software quickly and continuously. It promotes high customer involvement, rapid feedback loops, continuous testing, continuous planning, and close teamwork to

deliver working software at very frequent intervals, typically every 1-3 weeks. The original XP recipe is based on four simple values “ �simplicity, communication, feedback, and courage “ and twelve �supporting practices:

Planning Game

Small Releases

Customer Acceptance Tests

Simple Design

Pair Programming

Test-Driven Development

Refactoring

Continuous Integration

Collective Code Ownership

Coding Standards

Metaphor

Sustainable Pace

Don Wells has depicted the XP process in a popular diagram. In XP, the "Customer" works very closely with the development team to define and prioritize granular units of functionality referred to as "User Stories". The development team estimates, plans, and delivers the highest priority user stories in the form of working, tested software on an iteration-by-iteration basis. In order to maximize productivity, the

practices provide a supportive, lightweight framework to guide a team and ensure high-quality software.

CrystalThe Crystal methodology is one of the most lightweight, adaptable approaches to software development. Crystal is actually comprised of a family of agile methodologies such as Crystal Clear, Crystal Yellow, Crystal Orange and others, whose unique characteristics are driven by several factors such as team size, system criticality, and project priorities. This Crystal family addresses the realization that each project may require a slightly tailored set of policies, practices, and processes in order to meet the project 's unique characteristics. Several of the key tenets of Crystal include teamwork, communication, and simplicity, as well as reflection to frequently adjust and improve the process. Like other agile process methodologies, Crystal promotes early, frequent delivery of working software, high user involvement, adaptability, and the removal of bureaucracy or distractions. Alistair Cockburn, the originator of Crystal, has released a book, Crystal Clear: A Human-Powered Methodology for Small Teams.

Dynamic Systems Development Method (DSDM)DSDM, dating back to 1994, grew out of the need to provide an industry standard project delivery framework for what was referred to as Rapid Application Development (RAD) at the time. While RAD was extremely popular in the early 1990 's, the RAD approach to software delivery evolved in a fairly unstructured manner. As a result, the DSDM Consortium was created and convened in 1994 with the goal of devising and promoting a common industry framework for rapid software delivery. Since 1994, the DSDM methodology has evolved and matured to provide a comprehensive foundation for planning, managing, executing, and scaling agile process and iterative software development projects. DSDM is based on nine key principles that primarily revolve around business needs/value, active user

involvement, empowered teams, frequent delivery, integrated testing, and stakeholder collaboration. DSDM specifically calls out "fitness for business purpose" as the primary criteria for delivery and acceptance of a system, focusing on the useful 80% of the system that can be deployed in 20% of the time. Requirements are baselined at a high level early in the project. Rework is built into the process, and all development changes must be reversible. Requirements are planned and delivered in short, fixed-length time-boxes, also referred to as iterations, and requirements for DSDM projects are prioritized using MoSCoW Rules:

M - Must have requirements S - Should have if at all possible C - Could have but not critical W - Won 't have this time, but potentially later

All critical work must be completed in a DSDM project. It is also important that not every requirement in a project or time-box is considered critical. Within each time-box, less critical items are included so that if necessary, they can be removed to keep from impacting higher priority requirements on the schedule. The DSDM project framework is independent of, and can be implemented in conjunction with, other iterative methodologies such as Extreme Programming and the Rational Unified Process.

Feature-Driven Development (FDD)The FDD variant of agile methodology was originally developed and articulated by Jeff De Luca, with contributions by M.A. Rajashima, Lim Bak Wee, Paul Szego, Jon Kern and Stephen Palmer. The first incarnations of FDD occurred as a result of collaboration between De Luca and OOD thought leader Peter Coad. FDD is a model-driven, short-iteration process. It begins with establishing an overall model shape. Then it continues with a series of two-week "design by feature, build by feature" iterations. The features are small, "useful in the eyes of the client" results. FDD designs the rest of the development process around feature delivery using the following eight practices:

Domain Object Modeling

Developing by Feature

Component/Class Ownership

Feature Teams

Inspections

Configuration Management

Regular Builds

Visibility of progress and results

FDD recommends specific programmer practices such as "Regular Builds" and "Component/Class Ownership". FDD's proponents claim that it scales more straightforwardly than other approaches, and is better suited to larger teams. Unlike other agile methods, FDD describes specific, very short phases of work, which are to be accomplished separately per feature. These include Domain Walkthrough, Design, Design Inspection, Code, Code Inspection, and Promote to Build.

The notion of "Domain Object Modeling" is increasingly interesting outside the FDD community, following the success of Eric Evans' book Domain-Driven Design.

Agile Manifesto and PrinciplesThe Agile Manifesto, also called the Manifesto for Agile Software Development. The agile development manifesto represents the absolute cutting edge of the software development industry. It was created by representatives from Scrum, Extreme Programming, Adaptive Software Development, DSDM, Feature-Driven Development, Crystal and Pragmatic Programming.

The Agile Manifesto is created as an alternative to traditional heavyweight, document-driven software development processes such as the Waterfall Model. Agile software development focuses on keeping code simple, testing often and delivering functional bits of the application as soon as they’re ready.

In Agile project management process works as a team plays an important role. It has been proven that learning in group is very effective & the human interaction helps to accomplish great things. Computers and Books are important but individual’s interaction by sharing experience via debating, discussing and feeding off of each other’s ideas is more important.

It has four key values and twelve Agile Principles to guide an iterative and people-centric approach to Agile Software Development.

The values of the Agile Manifesto are:

1. Individuals and interactions over processes and tools2. Working software over comprehensive documentation3. Customer collaboration over contract negotiation4. Responding to change over following a plan

The Agile Manifesto

Twelve Principles behind the Agile Manifesto helps to make clear what it is to be Agile Software Development:

1. Agile first priority is to fulfill the customer need from beginning to end and continuous improvement to ad into valuable software.

2. Agile allow change in requirements in the late in the development as well.3. Agile works on delivering software regularly interval i.e. from couple of weeks

to couple of month based on project.4. Close, daily cooperation between business people and developers throughout

the project.5. Key point is to trust, support and motivate individuals to get it projects build

on time.6. Daily face-to-face conversation is key point in agile testing. This is most

efficient & effective way of communication.7. Measuring progress by the amount of completed work.8. Continually seeking excellence9. Harnessing change for competitive advantage10.Simplicity11.Self-organizing team come out with best architectures, requirements, and

designs.12.Regular adaptation to changing circumstances with more effective way.

Agile Project Management

TRADITIONAL VERSUS RAD MODEL FOR PROJECT MANAGEMENT

The traditional project management model focuses on locking the scope for a project and negotiating or varying the budget (including people and resources) and the delivery date. The PMI and ISO-9000 models for project management are based on this paradigm. In fact, the ISO-9000 definition of quality is derived from the model. Quality here is defined as delivering the scope that was promised, fully functional, on or before the delivery date.

When the scope is defined first, it forces the engineers to estimate the level of effort required to transform the ideas into

working code. As discussed in Chapter 4, estimations are prone to uncertainty, and the amount of uncertainty can be very large—resulting in time buffers of as much as 200% of the estimate.

The budget has considerably less uncertainty attached to it. Over a short time window, most or all costs are fixed and the staffing level, resources available, and cost of maintaining them are known. On longer projects, there may be some variance, but it is never likely to be in the order of 200%.

The date has almost no uncertainty attached to it. If the date has been determined by a new law, the constraint is external to the business. If the date has been chosen internally, it is also unlikely to shift by much. Entire marketing programs are arranged around dates, and the cost of missing a date is very high. Marketing dollars are deployed, sales staff and customer care personnel are trained for the new product arrival, stock market analysts have been informed, and customers are told when to expect the new product or system.

Generally, the date has the most certainty, the budget is a close second, and the scope is a distant third. The scope and, more importantly, the estimate attached to it have the greatest uncertainty.

The ISO-9000/PMI model for project management created the worst possible environment for managers. It created a world where the estimate had to be very accurate. The focus in the software engineering world, therefore, has been on achieving greater accuracy of estimates. A reinforcing loop was created where more analysis techniques were required to better understand software development, which would lead to better estimates. However, there was a side effect that created a balancing loop. More and more analysis techniques meant a higher barrier to entry, more and more paperwork, and longer and longer timescales while paperwork was created, read, debated, and agreed. The result was heavyweight, traditional software methods. Lengthening the timescales ultimately limited the ability of estimates to get any more certain.

The problem was recognized in the early 1990s by the Rapid Application Development movement (RAD), which turned the traditional model on its head by fixing the delivery date first, then varying the budget and scope to fit the date. However, RAD did not entirely eliminate estimating techniques or achieve negotiable scope buffers, see Figure 6-1.

Figure 6-1. Alternative focus of PMI and RAD PM models.

Most Agile methods, for example, DSDM are derived from earlier RAD approaches. The implication of this is that Agile methods require a negotiable scope and an agreed scope buffer in order to be successful. As discussed in Chapter 4, obtaining the customer agreement for a scope buffer—“optional” or “nice to have” requirements—is difficult. It requires trust between customer and supplier. Such a trust relationship does not generally exist at the initiation of a relationship between a software supplier and the customer for the system. The customer has learned from years of experience that software is always late, always over budget, and does not function properly. The customer has no trust in the software supplier.

One notable standout in the world of Agile methods is Feature Driven Development (FDD), which does not fix the delivery date. Instead FDD allows both the date and the scope to move within some tight bounds.1 This model provides the flexibility with which to gain the trust required for a fixed date and variable scope.

1 Jeff De Luca explains this in detail in Getting Flexible with Planning, Feature Driven Development Newsletter, January 2003, http://www.featuredrivendevelopment.com/node.php?id=508.

TASK PLANNING AND EFFORT TRACKING

The traditional model created a need for accurate estimating, which led to a management focus on determining the tasks to be undertaken and the effort involved in each task. There were perhaps thousands of years of project management history, and the paradigm was well established. The task and effort paradigm was mixed at the larger grained level with the Scientific Management paradigm to create phases of development and effective gates for partial completion of the project. The combination resulted in the Software Development Lifecycle (SDLC), or “waterfall,” model for software production. SDLC is examined more fully in Section 2.

The task planning and effort expended paradigm does not represent a systems thinking approach to management of software production.

Chapters 1–5 have shown that estimating, measuring, and tracking the effort expended is not useful in determining output from the system of software production—the value delivered to the customer. Task planning and effort tracking have been described as a one-dimensional model of project management [Koskela 2002].

Such a model is also compatible with cost accounting and is OE focused. What is really required is a model of project management that focuses on delivered value and management of inventory. Such a method would be compatible with Throughput Accounting and would be focused on T and I.

Koskela and Howell have proposed a three-dimensional model of project management, as shown in Figure 6-2, that focuses on managing the flow of value through a series of transformations [Koskela 2002]. Such a model would fit nicely with the Systems Thinking and Throughput Accounting-based model for software production proposed in Chapter 2.

Figure 6-2. Koskela & Howell's three-dimensional model for project management.

Cost Accounting Tracks Value Added

The traditional cost accounting world tracks value added to raw material as it passes along a value chain. In software development, this manifests itself as the measurement of effort expended in tasks that are all assumed to add value. This assumption is probably false. Many tasks in traditional software development do not add value, but produce by-product or waste.

Nevertheless, the completed time sheets from the software developers have been used to determine the value added. The value added to the raw material is determined as the amount of money spent completing the task. Hence, cost accounting values the incomplete inventory by the OE expended on it and not by the potential client value, Throughput (T). This is best explained with a diagram.

Figure 6-3 shows a simplistic example in which an idea is transformed into working code over a 6-week period. As each week goes by, the value recorded for Investment increases as value is added to the partially complete software. The cost of each transformation is booked as value added at the completion of each task.

Figure 6-3. Tracking value added as Investment in Inventory.

In Chapter 3, the concept that software ideas are perishable was introduced. The cost accounting approach increases the value of the Investment in the incomplete code, whilst Throughput Accounting would depreciate the value. Throughput Accounting assumes that the Investment is reducing due to the nature of change in the business world, whilst cost accounting reports the opposite. Cost accounting results in senior management believing that they have an asset when they may actually have a liability. The larger the project, the more misleading the numbers will be.

A large project may be due for delivery when it is discovered that it no longer meets the market requirements. The deliverable is of little Throughput value. Change requests will be submitted for new ideas that have current market value, that is, they have a Throughput value. The Investment, in the now worthless, partially complete software, will need to be written off.

The combination of tracking effort expended and recording it as value added produces misleading management information that results in poor quality executive decisions.

Throughput Accounting Tracks the Flow of the Investment Value

Throughput Accounting treats all effort expended in the system as Operating Expense. OE is treated as a cost and never attributed as value added. Throughput Accounting does not

recognize the concept of value added. Value is recorded at only two points in the system: the value of the input—Investment (I); and the value of the output—Throughput (T). While the input passes through the system before it is transformed into output, the Investment is depreciated. I is reduced during the system Lead Time (LT). Depreciating I creates an incentive to minimize LT. Cost accounting leads to local optimization by tracking value added. Cost accounting does not discourage the growth of LT. Through tracking the value of working code delivered, Throughput Accounting focuses management attention on the holistic system of software production, leading to global optima.

In Throughput Accounting, there is no need to track tasks and effort expended on each individual task. There is no need for software developers to fill out time sheets.

Figure 6-4 shows the same example as Figure 6-3, but using Throughput Accounting. An idea is developed into working code over a 6-week period. The flow of the Investment in the idea is tracked through each step of the process, but value is not added. This example does not show any depreciation during the 6-week period. The Throughput value is recognized only in week 6 when the software is delivered.

Figure 6-4. Tracking the flow of Investment value.

Tracking investment value in this manner is entirely consistent with tracking the inventory using the cumulative flow diagram presented in Chapter 5. The software production metrics in Chapter 5 are consistent with the financial metrics from Chapter 2, which are both compatible and consistent with the proposed three-dimensional model of Agile project management.

All of this creates the rather uncomfortable conclusion that traditional project management is obsolete in the world of Agile software development.

THE PROJECT MANAGER'S NEW WORK

Agile software development creates a paradigm shift for project managers. The job of project management is no longer to create a list of tasks, collect a set of estimates for each task, create a Gantt chart that predicts the end date for the project, and maintain the chart throughout the life of the project. All of that work is obsolete.

The project manager's new work is to assist the flow of value and the continuous generation of Throughput by maintaining the Issue Log and running down issues before they delay the delivery date. Unresolved issues prevent flow and cause Inventory buildup. The project manager monitors the project buffers and reports significant events—events that will impact the delivery date—to the senior management. This role is discussed in Chapter 7, and the full role for the Agile project manager is discussed in Chapter 8.

Tracking the Flow of Value with a Cumulative Flow Diagram

On a day-to-day basis the flow of value can be tracked using the software production metrics from Chapter 5 and the cumulative flow diagram. Figure 6-5 shows the inventory levels for each step in the software production system for a period of 6 weeks. Each unit of inventory represents a single client-valued idea that has reached a particular stage of transformation.

Figure 6-5. Tracking the flow of inventory.

Figure 6-5 can be visualized using the cumulative flow diagram Figure 6-6.

Figure 6-6. Cumulative flow of inventory for Figure 6-5.

SUMMARY

Donald Reinertsen [1997, ch. 11] stated that the choice of metrics for a design system should be simple, relevant (focused on value-added), self-generating, and leading (predictive). This chapter has shown that a three-dimensional model of project management that tracks the flow of value through a series of transformations can be achieved by using the software production metrics from Chapter 5, R and V, which are simple, relevant, self-generating, and leading. All of this can be easily visualized in a single graph—a cumulative flow diagram. Hence, Agile project management can be achieved by replacing a Gantt chart with a cumulative flow diagram and a plan for the release of inventory into the system.

The existing PMI/ISO model for project management is obsolete. It does not lend itself to a world of constant change and shortening business cycles. Attempts to improve the estimation of software and reduce the variance in order to better improve the results from the traditional model of project management are doomed to failure because of the balancing loop in the system, which creates more paperwork and lengthens lead times.

The existing model of project management was compatible with cost accounting, but generated misleading data that lulled senior management into believing that incomplete software was an asset rather than a liability.

Throughput Accounting is compatible with a three-dimensional model of project management that tracks the flow of value and does not record value-added on partially complete work. Throughput Accounting records effort expended on transformation as pure operating expense and depreciates the value of the initial investment in requirements. This provides better quality information to senior management who will then become focused on reducing lead times and realizing Throughput earlier.

WHAT IS AN AGILE TEAM AND HOW DO YOU FORM THEM?

A truly Agile team isn’t just any random group of people and it’s not a group of business analysts doing a daily standup to coordinate their work either.  It’s not merely a group of developers that meet every other week to do sprint planning. Nor, is an Agile Team a project team with folks matrixed across two or more other Agile teams.

WHAT IS AN AGILE TEAM?

An Agile team is a cross-functional group of people that have everything, and everyone, necessary to produce a working, tested increment of product.  Dedicate these people to the team, and as a rule, do not move them between or across teams as demands ebb and flow.

I’m going to suggest that the very definition of an Agile team  is getting in the way of forming Agile teams. Mostly, because we misunderstand what a product actually is.In the small, this guidance is clear, it’s the system.  All the way from user interaction to data and back and all the abilities to deploy and install said product into production. However, in the large, forming a team like this isn’t usually possible, and often not advisable—even if it ispossible.Also, in the large, a product is actually a sub-system of a larger systems-integration.

When you look at a product this way, it’s often possible to create a small, cross-functional group of people that has everything—and everyone—necessary to produce a working, tested increment of product.

BUSINESS CAPABILITIES

You should organize around products, or features, where you can.  Organize around subsystems where you have shared functionality. We call these business capabilities, collectively. Once you have the business capabilities understood, align the business capabilities with the technical architecture and ultimately the organizational architecture.

The intersection and alignment of business, technical, and organizational architectures is where you form a complete cross-functional group.  A team of people that have everything—and everyone—necessary to produce a working, tested increment of their part of the product.Because your business, technical, and organizational architectures are probably broken—you will have dependencies between these teams that you are going to have to manage. For now.

DEPENDENCIES

Over time, the job of the Transformation initiative is to break these dependencies because dependencies are evil and you need to break them.

The more you manage dependencies the less Agile you will be, period.

Over time, as you break dependencies, you will be able to treat each of these teams as pure agile teams.

Start forming teams that align business capabilities with technical and organizational architecture. Then, you are ready to begin the hard work of breaking dependencies. If not, all you can do is go through the motions of Scrum. Until you break the dependencies, you will never get the value you are working towards.

The reason you’re not feeling very agile is because you don’t have these kinds of teams.  You have way too many dependencies.

No amount of daily standup meetings is going to fix this problem.An Agile culture won’t do the hard work for you.

Agile EthicsThe purpose of ‘agile ethics’ is to facilitate working ethically at speed, and it is a practice that can be designed to operate in tandem with agile development. For those unfamiliar with agile development, it is — in its simplest form — a process whereby ideas are researched, prototyped, and then shaped by frequent testing with a potential user group. It allows for zany ideas to take shape, and it allows for businesses to harness creativity

as a way of finding market fit. It is the dominant ethos and way of working within technology organisations operating at speed, and is a process for creative and iterative invention where each iteration is an opportunity to learn more about the product and possibility you are working to shape. It is also a way of working, when not carefully managed, leads to haphazard and harmful creations that are flung into the world before their potential impacts are assessed. It is the management process for ‘move fast and break things’.

Agile development approaches are not inherently harmful. Organisations attempt to incorporate values into the method. But when non-diverse teams use agile methods they often have ethical blind spots (wilful and not) that can embed harm in their invention (diversity is a competency!).

Agile ethics is a process to operationalise values, iteratively identify and address ethical challenges of your innovations before you send them out in to the world, and adaptively refine processes so that as the capabilities of technology evolve, so does your ability to diagnose and prevent harm before it happens. Agile ethics is the explicit application of agile methods to ethical assessment, adaptation, and learning that allows for a team to mature its practices as it works at the bleeding edge. It employs agile methods to tackle ethical challenges, and inculcates ethical approaches within an agile development process.

It is not:

Delegating ethical analysis to a fixed part of an organisation (compliance, research, corporate social responsibility or otherwise)

Prescribing a fixed approach to ethics based on vague values (policies won’t cut it)

Encouraging your staff to reflect on ethics without designing methods or allocating resources to aid them in the process

A bandaid for underlying problems with governance and leadership

Agile ethics requires four things:

Decentralisation of critical, ethical thinking in an organisation or team

Iterative development of process that supports decentralised consideration of the implications of any given idea

Dedicated staff time to manage the process

Inclusion of diverse and (when appropriate) external voices

Agile Ethics Job DescriptionIn my experience, the team members most devoted to supporting ethical practice are either not embedded in the process or practice of inventing or are engaged in their ethics practices because they are particularly interested, not because they have been tasked with or supported to carry out the work. For an agile ethics

process to work, some staff time has to be devoted explicitly to it. Ethics as a dislocated practice or outsourced process will always fail.

What could that role look like?

Identification of moments in the design process where ethical consideration, planning, reflection, and decision-making are necessary

Facilitation of entire teams to reflect on ethical dimensions of their new work

Documentation of process that is both prescriptive (all staff know what process they are meant to be doing at any given time) and insights-focused (as you learn, you should reduce the cognitive load related to solved problems while keeping focused on upcoming ethical challenges)

Research and engagement with communities, researchers, and academics on the forefront of managing ethics

Management of a ‘diversity marshmallow strategy’ (i.e. what representatives from what communities should be included in design phases to identify and call out ethical blind spots that your team may have)

Influence on diversity, equity, and inclusion strategies to support the process of your organisation growing your ethical competencies by having more representative staff involved in your activities

Agility vs Agile: The Most Common Mistake in Agile

Adoption

In the recent years, the agile development has increased its popularity. First, it appeared in the software engineering, but it disseminated to other fields as well. This methodology is important for managing of different project types, so we are exposing some must-know agile practices.The adoption of the Agile methodology in the organisations could be difficult in some cases. On the market, there are many available development practices and project management practices, but the agile approach promises a fast and efficient way for product delivery with fewer obstructions and impediments on the way.To adopt the agile method does not mean just to practice its tools and artefacts; it means that you should change your team behaviour and the way of thinking. Of course, there are well-established tools and frameworks such as Scrum, Kanban, XP, etc. – all they could enable you to become agile, but you will also need to change your management approach.Agility is not just a tool you could apply — it is a character or behaviour that you possess, or that you don’t.

There are many organisations that have started an agile way of operation, and started applying its processes and tools into their environment before they’ve actually realised the importance of Agility over Agile. There are situations when the management insists that the company needs its teams to be Agile, but without realising the impacts of agility for the company as a whole. Such a situation will lead the management process in the wrong direction since they’re pushing ahead the Agile practices, instead of the real agility.In the agile approach, the software is developed in time-boxed units, which are usually from 1 to 4 weeks; they are called iterations. Each iteration is a complete software project, including requirements, design, coding, testing and documentation. It requires that product managers should elaborate and define a complete set of use cases that the product could possibly cover.

The sales department should stop relying on feature delivery and focus on delivering value.

The marketing department should change its approach from one-time product marketing to strategic and collaborative marketing.

The development team should thrive to become real problem-solvers, not just ordinary non-creative coders.

In order to have a real success of your Agile process, you should accept all above changes. Your agile iterations will not be efficient if your sales department needs a year-long cycle to make contracts with the clients.The most important role in the ‘agile’ organisation should be the product manager. He will be the leader of change in your organisation, making it possible the agile approach. The product manager should manage the backlog, communicate with stakeholders, inform the other groups in the organisation so that they fully understand the importance of being agile and using agile processes.The product manager will have the key role since he will motivate the team members to be more agile, from inception to the project closure. He should always know what is in – for the company’s members, and of course, for the customer.When you will adopt the agile approach, you will be able to focus on what’s needed now and in the near future, ensuring that you’re delivering what’s actually valuable to your clients and customers, not just forecasting what will be needed in the far future.At the simplest, to be agile means to enforce the change of your habits – it will bring changes to your personality, to the department, and the organisation. And finally, the human aspect of the agile methodology is also important – without training people you will fail in all attempts to become truly agile.

Here we present some tips on how to adopt the agile method smoothly:

Involve the customer – the agile approach needs an involvement of the client. When the client is actively involved in contributing ideas, features and functionality to the application, he is more likely to approve the result.

Define minimum viable product release – in this approach, your project team offers a minimal list of developed features to the client as soon as possible.

Test-driven development – the first type is functional test specified by the client and carried out by the project team and users. Other types of tests are the unit tests that are written and executed by the development team.

React quickly – in the agile development, programmers often commute their code several times a day, asking frequent builds of it, additional configuration and testing environments.

What is Agile Testing?A software testing practice that follows the principles of agile software development is called Agile Testing. Agile is an iterative development methodology, where requirements evolve through collaboration between the customer and self-organizing teams and agile aligns development with customer needs.

Advantages of Agile Testing Agile Testing Saves Time and Money

Less Documentation

Regular feedback from the end user

Daily meetings can help to determine the issues well in advance

Principles of Agile Testing Testing is NOT a Phase: Agile team tests continuously and continuous testing

is the only way to ensure continuous progress.

Testing Moves the project Forward: When following conventional methods, testing is considered as quality gate but agile testing provide feedback on an ongoing basis and the product meets the business demands.

Everyone Tests: In conventional SDLC, only test team tests while in agile including developers and BA's test the application.

Shortening Feedback Response Time: In conventional SDLC, only during the acceptance testing, the Business team will get to know the product development, while in agile for each and every iteration, they are involved and continuous feedback shortens the feedback response time and cost involved in fixing is also less.

Clean Code: Raised defects are fixed within the same iteration and thereby keeping the code clean.

Reduce Test Documentation: Instead of very lengthy documentation, agile testers use reusable checklist, focus on the essence of the test rather than the incidental details.

Test Driven: In conventional methods, testing is performed after implementation while in agile testing, testing is done while implementation.

Best Practices in Agile Testing1. Automated Unit Tests

2. Test Driven Development

3. Automated Regression Tests

4. Exploratory Testing

A document is considered to follow the agile principle if it is valuable, essential, and created or updated just-in-time. A documentation is created and maintained in an agile way, if all its documents follow this practice.

Domain

Documentation

Type

Collaboration

Principles

YAGNI Principle, KISS Principle, Teamwork

 

The agile manifesto states that running software is more valuable than comprehensive documentation. So comprehensive documentation has value. But there is no hard-and-fast rule of how much documentation does meet the expectations of all stakeholders. In order to get it right we need a couple of rules for guidance, create valuable increments, and then iterate. 

We categorized Agile Documentation as a practice and not as a principle. The reason for this is that the structure presented here is to complex to be a principle. One violated aspect of a principle is that it must not be further reducible. Therefore it needs to be considered a practice.

StructureAgile documentation requires that each document is valuable, essential, and created or updated just-in-time.

ValuableTeams need to determine the information needs of the stakeholders and provide the necessary information accordingly.

Therefore the first step for creating a document is the search for a stakeholder. Better yet, stakeholders identify their information need by themselves and ask the team for documentation. So there is at least one stakeholder required to justify the existence or maintenance of a single piece of documentation. This makes sure that at least one stakeholder values the document or knows an audience that values it.

EssentialThese stakeholders with an information need typically know exactly what they need to know. This way the document can be adjusted to exactly match this need. Create an essential instead of a comprehensive documentation.

Just-in-TimeLast but not least documentation quickly gets out of sync with reality. Time runs forth and a document needs to be maintained to keep up with the pace of time. Therefore it is

wise to wait for creating documents until they are needed. This keeps the maintenance costs low. In order to deliver documents just-in-time, teams need to employ automation and single sourcing to create documents quickly.

Advantages

The documentation responds to actual information needs. Every document is a liability. To

reduce the amount frees resources to be spent in more relevant issues, such as working

software.

Maintenance cost is reduced if every document created is known to be still relevant.

When documents are explicitly requested, they are more valued than documentation that is

assumed to exist.

Disadvantages

To deliver just-in-time needs tooling and training. This is a serious investment.

Stakeholders need to express their information needs. This may be difficult for some people.

Teams need to provide support do define these requirements with stakeholders.

Nine Drivers of The Agile Advantage

1. Leadership

To put it bluntly, leadership can make or break The Agile Advantage. Leaders set the tone and create the type of empowered culture that transforms an organization. “It’s all about culture. Your customer and process are important, but if you don’t have a culture where your people feel empowered to be adaptable, to learn and communicate, you won’t be able to serve the rest of the business,” explains Leslie Snavely, VP of marketing and corporate business development at CHG Healthcare Services.

2. Anticipating Change

Anticipating the market is a benefit of being more agile with data and frequent research. By understanding customer patterns, you’re able to foresee behaviors and get ahead othe competition. Elisa Steele, EVP of strategy and CMO at Jive Software puts it this way, “There are many times that no user told you that you needed to do [something], but you deeply know how the product works . . . you can actually do a leapfrog to innovate an idea, a program, an engagement opportunity that hasn’t been done before.”

3. Flexible and Focused

Flexible doesn’t mean loose or sloppy, it means that like an athlete, you keep your eye focused on the ball but you’re always ready to adapt – to sprint or turn on a dime if needed. “When we are focused we’ve been very successful in moving quickly and utilizing the right process to get things done,” describes one lead marketer.

4. Data Driven

New tools for big data and analytics provide more intelligence on consumer behavior than ever before. You have to embrace data analytics in an actionable way, measuring early and often to discover customer patterns and responses. Leslie Snavely of CHG Healthcare describes their approach, “Data shouldn’t just be analyzed; it should be actionable. We use our data to make decisions because it’s in a digestible form.”

5. Iterative and Experimental

A4M means taking risks with new ideas and innovative methods. Support a culture that encourages taking chances, evaluating, iterating, and then re-evaluating. May Petry, VP of digital marketing at HP, says, “Agile enables me to test, learn, iterate and execute much quicker. If we didn’t apply the agile lifestyle, I wouldn’t be able to iterate and respond to change as quickly as I can right now.”

6. Clear and Transparent

Operate with open visibility across teams as well as into goals, planning, performance and results. Get all teams working with clear, common objectives. Allen Olivo of Paypal advises, “If you want to move fast, you have to know where you are going. That’s why our goal is to join people together around a shared purpose. This is the essence of what we want to accomplish.”

7. Collaborative

A big change for many companies is that agility requires working across departments and roles in a flatter organization. Tom Vogl, CMO at The Clymb explains how they have done away with strict silos and hierarchy, “Being agile means having a strong degree of trust and respect across teams, In our case, people are not concerned about which group is going to get credit, but about what we’re delivering and figuring out how to work together across teams.”

8. Empowered

It’s crucial to enable decision-making at all levels while allowing the freedom to fail. Tobias Lee, CMO at Thomson Reuters describes how this works for his team, “People feel empowered to share ideas and are supported to go do these things. And that’s been very different, to feel like you can move fast with ideas you have because you’re not concerned that management may not support you.”

9. Customer-Centric

A4M companies put the customer at the center of all decisions, actions, and goals. “Knowing the customer, understanding the customer, talking to the customer, responding to the customer, and using their input to make marketing better. In short, agility is about responding to the market,” shares Ann Lewnes, SVP and CMO at Adobe.

A company that adopts these Nine Drivers does not ‘do marketing’ in the traditional sense. After all, even traditional marketing has almost completely transformed. A4M apply these drivers to a mindset and

methodology that empowers their organizations to better anticipate and respond to changes in the market, and in the process, outperform their competitors.

THE FOUR VALUES OF THE AGILE MANIFESTO

The Agile Manifesto is comprised of four foundational values and 12 supporting principles which lead the Agile approach to software development. Each Agile methodology applies the four values in different ways, but all of them rely on them to guide the development and delivery of high-quality, working software.

1. Individuals and Interactions Over Processes and ToolsThe first value in the Agile Manifesto is “Individuals and interactions over processes and tools.” Valuing people more highly than processes or tools is easy to understand because it is the people who respond to business needs and drive the development process. If the process or the tools drive development, the team is less responsive to change and less likely to meet customer needs. Communication is an example of the difference between valuing individuals versus process. In the case of individuals, communication is fluid and happens when a need arises. In the case of process, communication is scheduled and requires specific content.2. Working Software Over Comprehensive DocumentationHistorically, enormous amounts of time were spent on documenting the product for development and ultimate delivery. Technical specifications, technical requirements, technical prospectus, interface design documents, test plans, documentation plans, and approvals required for each. The list was extensive and was a cause for the long delays in development. Agile does not eliminate documentation, but it streamlines it in a form that gives the developer what is needed to do the work without getting bogged down in minutiae. Agile documents requirements as user stories, which are sufficient for a software developer to begin the task of building a new function.The Agile Manifesto values documentation, but it values working software more.3. Customer Collaboration Over Contract NegotiationNegotiation is the period when the customer and the product manager work out the details of a delivery, with points along the way where the details may be

renegotiated. Collaboration is a different creature entirely. With development models such as Waterfall, customers negotiate the requirements for the product, often in great detail, prior to any work starting. This meant the customer was involved in the process of development before development began and after it was completed, but not during the process. The Agile Manifesto describes a customer who is engaged and collaborates throughout the development process, making. This makes it far easier for development to meet their needs of the customer. Agile methods may include the customer at intervals for periodic demos, but a project could just as easily have an end-user as a daily part of the team and attending all meetings, ensuring the product meets the business needs of the customer.4. Responding to Change Over Following a PlanTraditional software development regarded change as an expense, so it was to be avoided. The intention was to develop detailed, elaborate plans, with a defined set of features and with everything, generally, having as high a priority as everything else, and with a large number of many dependencies on delivering in a certain order so that the team can work on the next piece of the puzzle.With Agile, the shortness of an iteration means priorities can be shifted from iteration to iteration and new features can be added into the next iteration. Agile’s view is that changes always improve a project; changes provide additional value.

Perhaps nothing illustrates Agile’s positive approach to change better than the concept of Method Tailoring, defined in An Agile Information Systems Development Method in use as: “A process or capability in which human agents determine a system development approach for a specific project situation through responsive changes in, and dynamic interplays between contexts, intentions, and method fragments.” Agile methodologies allow the Agile team to modify the process and make it fit the team rather than the other way around.

Features and Capabilities A Feature is a service that fulfills a stakeholder need. Each feature includes a benefit hypothesis and acceptance criteria, and is sized or split as necessary to be delivered by a single Agile Release Train (ART) in a Program Increment (PI).

A Capability is a higher-level solution behavior that typically spans multiple ARTs. Capabilities are sized and split into multiple features to facilitate their implementation in a single PI

. Features also lend themselves to the Lean UX process model, which includes a definition of the Minimum Marketable Feature (MMF), a benefit hypothesis, and acceptance criteria. The MMF helps limit the scope and investment, enhances agility, and provides fast feedback.  Capabilities behave the same way as features. However, they are at a higher level of abstraction and support the definition and development of large Solutions.

Details Features and capabilities are central to the SAFe Requirements Model. They are critical to the defining, planning, and implementing Solution value. Figure 1 provides the broader context for these work items:

Figure 1. Features in the SAFe context Figure 1 shows that solutions are developed using features. Each reflects a service provided by the system that fulfills some important stakeholder need. They are maintained in the Program Backlog and are sized to fit in a PI so that each delivers new value. Features can originate from either the local context of the ART or they may result from splitting Epics or capabilities.

The Program and Solution Kanban systems support the flow of features and capabilities, where they progress through the funnel, analyzing, backlog, implementing, validating, deployment, and release states. This process provides reasoned economic analysis, technical impact, and strategy for incremental implementation.

Product Management and System Architect/Engineering own the features and enablers, respectively. Nonfunctional Requirements (NFRs) define system attributes such as security, reliability, performance, maintainability, scalability, and usability. NFRs serve as constraints or restrictions on the design of the system across the different backlogs. Features are prioritized using Weighted Shortest Job First (WSJF) and are planned and reviewed at PI boundaries. They are split

into Stories, and are implemented, integrated, tested, and demonstrated as the functionality becomes available.

Describing Features

Features are defined using a Features and Benefits (FAB) Matrix:

Feature – A short phrase giving a name and context

Benefit hypothesis – The proposed measurable benefit to the end user or business

Avoid defining features with the ‘user story voice’ format that’s designed to support one user role; features typically provide functionality for multiple user roles. Furthermore, using the same method to describe user stories and features may confuse the business, especially since they are not normally familiar with stories.

Figure 2 illustrates an example FAB with four different features:

Figure 2. Features and benefits matrix

Creating and Managing Features

Product Managers, in collaboration with Product Owners, and other key stakeholders, define features in the local context of an ART. Some arise as a result of splitting epics.

System Architects typically create enabler features. The program backlog is used to maintain enablers alongside business features.  Enablers pave the Architectural Runway and support exploration, or may provide the infrastructure needed to develop, test, and integrate the initiative.

Just like business features, enabler features may originate from epics or emerge locally at the ART level. Enablers that make it through the Kanban system will be subject to capacity allocation in the program backlog to ensure that enough emphasis is placed on both furthering the solution and

extending the architectural runway.  At each PI boundary, the percentage of resources to be allocated to new features (or capabilities) versus enablers is estimated to guide the train.

Prioritizing Features

The WSJF prioritization model is used to sequence jobs (e.g. features, capabilities) based on the economics of product development flow. Since implementing the right jobs in the right sequence produces the maximum economic benefit—it is hard to overestimate the importance of this critical process. Product and Solution Management have the authority to prioritize features, while System and Solution Architects and Engineering have the authority to prioritize enabler features.

Estimating Features

Feature estimation supports forecasting value delivery, applying WSJF prioritization, and sizing epics by splitting them into features and summing their individual estimates. Feature estimation usually occurs in the analysis state of the Program Kanban and relies on normalized estimation techniques, similar to the methods used by Agile teams (see the Iteration Planning article for more detail).  During analysis, select subject matter experts from the ART engage in exploration activities and preliminary sizing. During the analysis state, sizing features do not require splitting them into stories or the inclusion of all the teams that might develop them.

Accepting Features

Acceptance criteria are used to determine whether the implementation is correct and delivers the business benefits. Figure 3 provides an example:

Figure 3. Feature with acceptance criteria Acceptance criteria mitigate implementation risk and enable early validation of the benefit hypothesis. Moreover, acceptance criteria are typically the source of various stories, as well as functional tests, which are developed and automated to support refactoring and regression testing. While typically applied to stories, Behavior-Driven Development (BDD) creates better alignment and detailed acceptance tests for features. Product Management is

responsible for accepting the features. They use acceptance criteria to determine whether the functionality is properly implemented and nonfunctional requirements met.

Capabilities

Most of this article is devoted to describing the definition and implementation of features, as they are the most common description of system behavior. Capabilities exhibit the same characteristics and practices as features. For example, they:

Are described using a phrase and benefit hypothesis

Are sized to fit within a PI, however, they often take multiple ARTs to implement

Are reasoned about and approved using the Solution Kanban.  The Solution Backlog holds approved capabilities

Have associated enablers to describe and bring visibility to all the technical work necessary to support efficient development and delivery of business capabilities

Are accepted by Solution Managers, who use the acceptance criteria to determine whether the functionality is fit for purpose

Capabilities may originate in the local context of the solution or occur as a result of splitting portfolio epics that may cut across more than one Value Stream. Another potential source of capabilities is the Solution Context, where some aspect of the environment may require new solution functionality.

Splitting Features and Capabilities

Capabilities must be decomposed into features to be implemented. They, in turn, are split into stories consumable by teams within an iteration. SAFe provides ten patterns for splitting work, as described in Leffingwell [1], chapter 6.

Workflow steps

Business rule variations

Major effort

Simple/complex

Variations in data

Data methods

Deferring system qualities

Operations

Use-case scenarios

Breaking out a spike

Figure 4 illustrates splitting a capability into features.

Figure 4. A capability split into features