May – 5th agile principle

Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.

All agile principles are about the “how” as in “how to get things done”. If there is any principle that touches upon organisational culture, it is this one. We can ask: How do people in an agile team interact and contribute to an organization’s goal? What are the underlying beliefs, values and assumptions of an agile team? So, the fifth agile principle is about the “how” of project management and organisational culture.

There are three propositions in this statement. The first one is to build projects around motivated individuals. Notice that there is no mention of the words team, management, or leadership. The emphasis is instead on individuals and motivation. Individuals carry out tasks and take responsibility. Motivation is the force that propels them. Successful completion of a project is not the outcome of good leadership, good management, and not even a good team. It is achieved because motivated people who work together.

The topic of motivation is very important. At the same time, it is left open where motivation comes from and how individuals are motivated. They may be motivated because they share the same ideas ideas and goals. They may be motivated by the challenge that the projects presents. They may be motivated, because their work allows them grow their understanding and abilities. Or they may simply love the work they do. Whatever the source of motivation may be, it is key to the success of the project. Motivation is also contagious. If team members are highly motivated, they create an environment in which it is hard to stay unmotivated.

The focus on individuals is directly tied to the first of the four agile values: “Individuals and interactions over processes and tools.” Individuals bring with them not just motivation, but specific skills and experience that is valuable to others as well as to the overall project success. Individuals are integral parts of a team and are not easily replaced. They inevitably affect group dynamics and leave a personal mark on the work project. Which is why agile teams are often composed of multiple senior developers.

The second proposition is: “give them the environment and support they need.” To begin with, this includes the physical environment. A team obviously needs some sort of space where collaboration takes place. Traditionally, this is a shared office where people come together and communicate face-to-face. Increasingly, this is also virtual space that teams configure to their needs for online collaboration. There are a myriad ways of doing this. Suffice to say that physical shared space is preferred in agile project management. Physical space is conducive to informal and efficient communication.

Besides space, people need workstations, laptops, servers, equipment, software, tools, online resources and other “physical stuff” required to accomplish the given task. The term “environment” extends into the non-physical realm, however. A good work environment entails non-physical attributes, such as being safe, pleasant, respectful, rewarding, encouraging and stimulating. If you find that your work environment has all of these attributes, consider yourself lucky.

The support part of this statement plays in tandem with the environment part. A good environment is always supportive. Apart from financial support, this primarily means providing a platform and structure for cooperation. This could be the way a team organises its workflow, for example. But it is actually much more. Support can again mean physical and non-physical things. A good coffee machine and pleasant offices may be considered just as important as a well-maintained backlog and intellectually inspiring tech talks. At the top of the list, you are likely to find non-physical qualities such as transparency, recognition, and good work-life balance.

The third and final proposition of the 5th agile principle is: “Trust them to get the job done.” This piece of advice is most telling about the organisational culture that goes along with agile development. It is a radical departure from traditional top-down management. In a typical waterfall project, goals and milestones are prescribed by project leads and managers. The fulfilment of these goals is then ensured by implementing measures to gauge and control project progress. Or at least that is the idea.

In reality, both planning and measuring progress are often flawed. For example, the plan may contain a high degree of ambiguity, or the measurement does not regard code quality. By contrast, agile development operates on the assumption that the desired outcome (project success) follows naturally from providing the right conditions. This means, if there are motivated people working in an environment that is conducive to cooperation and if they receive adequate and sufficient support from management, then they will automatically get the job done. In fact, they will even get the job done in suboptimal conditions as long as they remain motivated.

The advise to trust people to get the job done comes from a place that has embraced a non-autocratic style of management. Responsibility and decision making is delegated to the individuals who work on a project. Managers assume the role of mentors and coaches rather than that of a dictatorial leader. Much emphasis is put on intrinsic motivation instead of extrinsic rewards and control mechanisms.

April – 4th Agile Principle

Business people and developers must work together daily throughout the project.

We are now getting to one of the most widely ignored principles of agile development. It is clear, succinct and quite definite. It says that business people and developers must work together daily. Note that it doesn’t say business people and developers should work together daily. The keywords are must and daily. Why is this principle often ignored? Because business people are often too busy to talk to developers. There are several reasons for that. First of all, they usually have other responsibilities than managing software development. Second, they may simply not be available every day. Third, business people and developers often don’t understand each other. It’s almost as if they speak a different language. Developers speak about technology and business people speak about goals, opportunities, and strategies.

Before we go into these issues, let’s briefly elaborate why it is important that developers and business people cooperate on an ongoing basis. Unlike the waterfall method or any other method that is based on a grand plan, agile development relies on a progressive formulation of requirements. This is the same feature that makes agile development adaptive and open to change. The drafting of requirements happens incrementally and thereby mirrors the development process. Specifications evolve throughout the project. There is no single prescribed method for how business requirements are being translated into detailed technical specifications. It can be done in a number of ways. However, it is understood that business people and developers must be in an ongoing dialog to make this happen.

Frequently, requirements begin with a high-level road map or whitepaper. This document contains a description of the overall goals and high-level functionality of the project. It is generally too abstract to be used for technical implementation. However, it may be followed a description of the envisioned architecture. The next step consists of defining different large-scale features (epics) that touch upon distinct aspects of functionality. This step again requires a dialogue of business people and developers. Epics are still too abstract and too large to be worked on directly. The entire process of requirements gathering can be seen as a successive refinement of specifications to the point where specifications can be encoded in computer language. Epics are broken down further into units of work that agile teams consider appropriate for concrete implementation, so-called user stories.

A user story is a conceptual tool of agile development. It describes a software feature from the perspective of a user. For example: “As an administrator, I want to be able to approve new comments before they are posted.” This is a proper user story containing a user role and a feature description. During the course of technical planning of a user story, further details are specified, such as the user interface particulars for that specific story. Diagrams, tables and UI mockups may be created during this phase. This implies again that there is dialogue between those who provide specifications (business) and those who implement them (developers). Without continuous cooperation, requirements end up being too vague and software artifacts end up being incomplete or flawed. The requirements refinement process runs parallel to implementation and testing. It requires management from the business side. Together, they make up a sort of pipeline that runs from high-level specifications to usable software.

In a typical Scrum team, there is an appointed manager (called “product owner”) who leads the requirements refinement process. The product owner acts as a sort of intermediary between business and development. On the other hand, a typical Kanban team is cross-functional and has no appointed roles. Members from business provide guidance directly without a project manager. Project management is often handled on demand by individual team members, depending on the nature of the task. In a Crystal team, project management depends on team size. There may or may not be an appointed project manager, often an executive sponsor. Business and development come together for Blitz planning sessions to define tasks and schedules. The refinement process is informal and relies on other methods such as co-location, daily meetings, or brief review-and-feedback loops with expert users. The problem of translating business requirements into software features and codeable functions can be solved in many ways. The one thing that all the different agile methods have in common is that business people and developers work together on an ongoing basis.

What can be done to improve communication between business people and developers? The problem of allocating sufficient time for exchanges can be solved in different ways. Appointing a product manager who works face-to-face with the team works well. Setting up regular meetings, such as feature planning, iteration planning, reviews, and backlog refinement meetings also works well. Having an executive sponsor working with the team is likewise a good solution if the sponsor is approachable and dedicates enough time to the task. Even informal communication can succeed if business people and developers are co-located at the same work space. The language problem can at least partly be tackled by developing a domain-specific vocabulary. Organisations usually have quite specific structures, roles, workflows, service offerings, etc. It is important to agree on a fixed terminology for these when phrasing requirements. This helps eliminating ambiguity, because ambiguity and vagueness are the principal obstructions to a successful implementation.

In summary, the 4th agile principle describes one of the most important factors to determine success or failure of software development projects.

March – 3rd Agile Principle

Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.

You might wonder how the third agile principle differs from the first. The first principle talks about “early and continuous delivery” of software. This sounds a bit similar to “delivering software frequently”. However, there is a significant difference. The first principle is all about customer satisfaction. It is realised by continuously delivering value to customers. The third principle is all about method. The principal method used to achieve the goals of the first principle is development in iterations. An iteration is a defined time span during which the entire software development life cycle (SDLC) is traversed. An iteration starts with requirements analysis and ends with software delivery. It can be modeled as a closed and repeating cycle.

If we recall the waterfall model, there are some major differences. Mot importantly, the waterfall model traverses the software development cycle only once. This usually takes a much longer time. It is common that the duration of this long-term traversal cannot be predicted exactly. For that reason, deadlines are often postponed. Another major difference is that roll out/deployment and maintenance phases are periods at the end of the waterfall SDLC, whereas agile methods do not stipulate predetermined phases for these activities at all. Agile teams carry out maintenance “on the go”; it is part of the normal development work.

The time frame of an agile iteration is more rigid, by contrast. It is commonly fixed and takes anywhere between a few weeks and a few months. For example, teams that use Scrum often work in cycles of 2-4 weeks. There is no delay or postponement. Instead, if a feature is not ready, it is moved to the next iteration. The quantity of work completed within this relatively short amount of time is of course much smaller. So, at the beginning of each cycle, the team continues to build upon the foundation laid in the previous cycles. The process is therefore also incremental. This has certain advantages for both developers and clients.

Let’s state again that the agile process is both iterative and incremental. This is important. At the end of each iteration, new features and fixes are demonstrated to the stakeholders. In many cases, the iteration also results in a release, which means that software is deployed to production at the end of a single iteration. However, this is not written in stone. For example, a team may decide to work in 2 weeks iterations while adopting a release cycle of 4 weeks to match maintenance windows. Another team may prefer a continuous delivery model where features are released to production as soon as they become available.

It does not matter, as the iteration is not strictly coupled to the release plan. What matters is that software is delivered frequently and that the time span of an iteration is kept as short as practicably possible. This makes for a short feedback loop which allows stakeholders to intervene quickly. It increases the control of business stakeholders and allows for an amount of flexibility that is impossible to attain with the traditional waterfall process. For example, change requests and bug fixes can often be implemented and released within a single iteration making for a time to market that can simply not be achieved with any other method.

From what has been said, it follows that the agile process is also evolutionary and adaptive. Because large scale features are built incrementally over the span of multiple iterations, developers build on the foundation of existing architecture and functions. New blocks of software are added to existing blocks. Existing blocks are sometimes refactored or changed. It is therefore possible to test concepts in practice before a feature is completed. It is also possible to improve concepts and functions over the span of multiple iterations. The end result is always working software.

This means that software features, especially large scale features (called “epic” in Scrum methodology), are not typically conceived at the drawing board. Instead, prototypes and proof-of-concepts make their way into working software long before the planning and implementation of a large scale feature is completed. This is another major difference to the waterfall model. The key advantage provided by a short feedback loop is that bugs, logical errors and flawed concepts can be spotted and corrected early. This keeps the cost of such improvements to a minimum.

Because the evolutionary and adaptive nature of the agile software development process, planning and design is often restricted to a relatively small time frame and is open to change. For example, the requirements for implementing an epic could change midway during one of the many iterations it takes to complete the epic. In some cases, these requirement changes necessitate rethinking and altering existing features or even rethinking architecture. Code refactoring, the restructuring and improvement of existing code without changing its functionality, is therefore very important in agile development. Without continuous refactoring, agile projects are in danger of accumulating technical debt.

Continuous refactoring is perhaps the price that has to be paid for the extreme flexibility and quick time to market that agile development affords. A team that follows an adaptive approach must guard against code smells and software entropy. Only with sustained attention to these problems, software will stay maintainable and extensible in the long run.

January – 1st Agile Principle

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.

The year has 12 months and agile development is based on 12 principles. Today, let’s start with the first agile principle. It is about customer orientation, perhaps the main motivation for agile development. Some of you might know, that it is now 18 years ago since a group of software engineers came together in Snowbird, Utah for a brief winter conference on project management. The result of that meeting was the well-known Agile Manifesto. It had a big and lasting impact on the software industry. Somewhat later the Agile movement started out and today, agile methods can be considered mainstream. However, back then things were different.

At university and during the early years of my career I learned that software development is divided into six stages. It starts with requirements analysis followed by three production phases, followed by deployment and maintenance. It was understood that the software development lifecycle (SDLC) phases are strictly linear and sequential. One is completed after the other. The customer is only involved in the first and the two last of these phases. Software companies spent enormous efforts on analysis, planning and documentation in order to get cost and time estimates right. Customers had to be enormously patient to wait for functioning software and they had no say in its production.

This process carried significant risks and turned out to be frustrating for both parties. Although customers initially received detailed contract specifications and a fixed price offer, the product was regularly late and below expectations. Even worse, some requirements changed during implementation and thus the software was already outdated at the time of delivery. Another costly change order was then inevitable. Things weren’t much better for developers. Unforeseen events and technical difficulties led to exceedance of cost and time estimates. In the worst case scenario, these circumstances left the developer unable to fulfill the contract and pushing towards bankruptcy. The client received either no product, or an unusable product for their investment.

In 2001, I was managing my second startup company and had no intention of repeating past mistakes in project management. Like many others at the time, I used a homegrown set of lightweight methods for SDLC management. I had acquired these during the late nineties in my practical work with different clients. I knew nothing about the Agile Manifesto at the time, but I found that the traditional waterfall approach didn’t work for us. Instead, I visited my clients every two weeks. During a long meeting which often took the larger part of a day, I would first present the new features that my team and I had developed. I would then install the update on my clients’ servers (this was well before the time of Internet-based deployments). Finally, I would discuss the most-wanted features and changes for the next cycle. There was an understanding that if the client found any bugs, they would be fixed immediately within a single release cycle.

Why did this work so well? Because the customer was always kept in the loop. They received usable software every two weeks that provided actual business value. They could control and even participate in the design process. They could correct mistakes early. Last but not least, their financial commitment wasn’t burdened by huge risk, because they paid monthly installments. This way of working puts the client in control and keeps them happy. And this is exactly what the first agile principle is about. I learned about agile project management only some years later and I found it to be an excellent fit for what we were doing. It confirmed our practice as a development company and it also broadened and enhanced our methods.

The reason why the this principle is the first, is given in the beginning clause: our highest priority is to satisfy the customer. Fundamentally, the agile methodology is about customer satisfaction. Normally, the customer is thought of as a third party outside the software company, but it could very well be the same company doing in-house development. It doesn’t matter. In the latter case, the customer role is filled by another department within the organisation. It is important to note that neither technical goals, nor abstract principles of management provide the foundation for agile development, but business goals. The middle part of the sentence mentions early and continuous delivery. This makes perfect sense from the perspective of developers, because software artefacts evolve and grow in small incremental steps. It also makes sense from the perspective of the customer, because they can begin using individual features before the entire package is completed.

Even more benefits are reaped by early and continuous delivery. The customer can control and prioritise the development of individual components. Mistakes can be corrected cost-efficiently at an early stage. The customer can verify or invalidate concepts in practical application. Developers are able to create proof-of-concepts without committing to a specific design or technology too early. Finally, the first agile principle speaks of the delivery of valuable software. The value of software is what clients and developers ultimately aim to realise together. This always translates into some sort of business value. For example, the software might enable the client to respond faster to their own clients. Or it may automate some task which previously had to be done in a tedious manual way. Or it may enable the client to gain deeper insights into markets, opportunities, and risks. The possibilities are endless. The sooner the software enters production stage, the earlier the customer can reap its benefits.

In summary, the first principle encapsulates the motivation and mission for agile development. It’s all about customer satisfaction and providing business value through software.

The Agile Samurai

The Agile Samurai

The Agile Samurai
by Jonathan Rasmusson
1st edition, 280 pages
Pragmatic Bookshelf

Book Review

Over the last ten years, I've been working with teams with different degrees of commitment to the agile process, ranging from non-existing to quite strong. I was looking for a text that summarises agile methodology to help me formalise and articulate my own experiences, and of course to enhance my knowledge of some of the finer points of agile practices. I have to admit that this book did not meet my expectations. The first eighty pages up to chapter six are mostly about project inception and read like a prolonged introduction. From chapter six onwards, the author finally comes to the point and discusses the core concepts of agile processes, so the book does get better with increasing page numbers. Unfortunately, Scrum isn't discussed at all, instead Kanban is introduced in chapter eight. The discussion of typical technical processes, such as refactoring, TDD, and continuous integration is compacted into several brief chapters at the end of the book.

The writing style is very informal; the author uses a conversational tone throughout the book. Almost every page contains illustrations, which makes it an easy and quick read. The style of the book is comparable to the Head First books. It left me with the the impression that I sat in an all-day meeting where someone said a lot of intelligent things to which everyone else agreed. Unfortunately, not many of these things seemed radically new or thought-provoking, so I fear I won't remember many of them next month. Of course, this may be entirely my own fault. I prefer a more formal, concise, old-school language. I also prefer dense and meaty text books with lots of diagrams, numbers and formulas. In return, I can dispense with stick figures, pictograms, and even with Master Sensei (a guru character used in the book). I feel that a lot of the deeper and more complex issues of agile project management have simply been left out.

To be fair, it must be mentioned that I probably do not fall into the target group for which this book was written. It is more appropriate as an introductory text for people who are new to agile project management, or even new to the entire business of project management. Think "trial lesson" and "starter course".