Subscribe to the blog
Agile principles and values paved the way for smarter, faster, better software development.
There’s a critical character stat in the old RPG video game Fallout 2.
It’s called agility.
Adding points to your character’s agility allows them to move more times during a conflict and increases their ability to dodge attacks.
Agility is all about mobility and reflexes.
Not unlike Agile software development where you have to be prepared to pivot a project without warning or dodge a variety of software bugs and errors.
But Agile works…
Better than almost any other software development philosophy.
What makes Agile work so well are the principles and values it’s built upon.
We explore the founding principles and values of Agile below, and we also show you how to put Agile into practice.
But before we dive in, let’s define our terms.
What is Agile?
As we pointed out in the videogame example above, “Agile” is simply the ability to create and respond to change quickly.
It’s the key skill for surviving and adapting to uncertain and turbulent environments.
What is Agile Software Development?
According to Wikipedia:
“Agile software development is an approach to software development under which requirements and solutions evolve through the collaborative effort of self-organizing and cross-functional teams and their customers and end users. It advocates adaptive planning, evolutionary development, empirical knowledge, and continual improvement, and it encourages rapid and flexible response to change.”
Very wordy (which is on par for Wikipedia entries), but it’s also correct.
And this definition will make a lot more sense once you understand the history of Agile’s development along with its Manifesto.
What is the Agile Manifesto?
The 4 values and 12 principles of Agile are so simple and yet so powerful.
The Agile Manifesto was a codification of 4 values and 12 principles (which we’ll get into shortly) comprising this new way of developing software.
Between February 11-13, 2001, 17 developers with different backgrounds met at the Lodge of Snowbird ski resort in the Wasatch mountains of Snowbird, Utah to vacation and discuss a common model for software development.
That’s where the Agile Manifesto was born.
Here are the 14 authors of the Agile Manifesto:
- Mike Beedle, founder and CEO of e-Architects Inc.
- Arie van Bennekum, actively involved in the Dynamic System Development Method (DSDM).
- Alistair Cockburn, founder of Humans and Technology.
- Ward Cunningham, founder of Cunningham & Cunningham, Inc.
- Martin Fowler, the Chief Scientist for Thoughtworks.
- Jim Highsmith, the primary developer of the "Adaptive Software Development" Agile Method and author of a book by the same name.
- Andrew Hunt, a partner in The Pragmatic Programmers, and co-author of the best-selling book The Pragmatic Programmer: From Journeyman to Master, the new Programming Ruby, and various articles.
- Ron Jeffries, the proprietor of XProgramming.com, a consultant with Object Mentor, and the author (with Ann Anderson and Chet Hendrickson) of Extreme Programming Installed.
- Jon Kern, expert in product development.
- Brian Marick, programmer and software testing consultant.
- Robert C. Martin, the president and founder of Object Mentor Inc.
- Ken Schwaber, president of Advanced Development Methods (ADM).
- Jeff Sutherland, Chief Technology Officer of PatientKeeper.
- Dave Thomas, co-author of The Pragmatic Programmer.
What are the 4 Values of the Agile Manifesto?
The Manifesto states 4 values of Agile:
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
They go on to say:
“While there is value in the items on the right, we value the items on the left more.”
Now let’s take a deeper dive into each one of those values and flesh them out a bit more.
1. Individuals and Interactions Over Processes and Tools
The most important assets in your organization are the people working for you, not the tools they use to work.
And improved communication and collaboration is how things actually get done, rather than following a process.
Of course, processes and tools are essential. Your developers can’t work without them.
But even if each developer had the top tools, a big office, and the best processes with the caveat being they have to work alone, isolated from everyone else…
They wouldn’t accomplish half as much as a team of developers practicing excellent communication and cooperation with subpar tools and processes.
Because software development is ultimately about people. The people creating the software (developers), the people who want it built (product owners), and the people who use the software to improve their lives and accomplish their goals (the end users).
The bottom line is, pick the right people first and get them working well together, then gather the tools and processes that support them and the project.
2. Working Software Over Comprehensive Documentation
What’s more important?
Software that’s functional or documentation that’s flawless?
In the old days of Waterfall software development (which we’re going to cover later in this post), a lot of time was spent meticulously outlining and documenting the software project long before coding and testing began.
- Technical specifications.
- Technical requirements.
- Interface design documents.
- Test plans.
- Documentation plans.
- And the list goes on.
Plus, each of these exchanged multiple hands, getting approval throughout. Or worse, disapproval and getting tasked with being rewritten.
You can imagine the long delays that resulted from this tedious, exhaustive process.
The Agile way is the opposite.
You get just enough documentation to start developing.
Documentation isn’t eliminated. Instead, it’s streamlined. You don’t want to bog down developers with specs and details that are unimportant at a particular stage of development.
As the software is developed, next steps are reevaluated, and further documentation is created when required.
3. Customer Collaboration Over Contract Negotiation
In the old days of software development, the product owner (the “customer” in this case) would go into great detail about what they wanted.
Then the developers would create a final product and deliver it to the customer and request their feedback.
And that’s when negotiations would begin.
So if the development team didn’t deliver what the customer wanted, they would have to drag their feet back to the lab and rework large portions of what they’ve already accomplished.
And if the changes are severe, they may have to rewrite most of the code.
This was not optimal.
This Agile value dictates that the customer stay involved throughout the entire product development process.
Just as collaboration between team members is important, so is the collaboration between customers and developers.
As you’re developing the software, the customer can weigh in with their input at any time - correcting course before developers go too far in the wrong direction.
This value also means you could use the input of end users in addition to the customer or as a substitute for them if the customer doesn’t want to be involved or can’t be.
At the end of the day, you want a strong, real relationship between the development team and the customer. Contracts are important, and you have to have those. But developing a genuine connection with your customer will help gain insights and feedback that make for way better software development.
4. Responding to Change Over Following a Plan
“Life moves pretty fast. You don’t stop and look around once in a while, you could miss it.”
Yes, you can learn software development lessons from Ferris Bueller’s Day Off.
This Agile value encapsulates Ferris’s point:
Be ready for anything that comes at you, and be prepared to notice it and act on it.
Traditionally, changes in software were expensive, difficult, and avoided if possible.
The idea was to document everything so meticulously that the developers wouldn’t miss a thing and the end product would be exactly as described.
But as any developer knows, this fantasy never becomes reality.
The men who developed Agile knew this, too.
That’s why Agile stresses short iterations that build one on top of the other.
So you work in sprints, get feedback, evaluate the current pieces of software, and route a course for the next iteration.
This is short, easy to manage, and most importantly, easy to fix software development.
And while change used to be loathed…
Agile practitioners embrace change. They see it as an opportunity to make marked improvements, to add more value.
What are the 12 Agile Manifesto Principles?
In addition to the 4 values, the creators of the Agile Manifesto also laid out 12 principles that form the foundation of this philosophy for software development:
- Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
- Welcome changing requirements, even late in development. Agile processes harness change for the customer's competitive advantage.
- Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
- Business people and developers must work together daily throughout the project.
- Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
- The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
- Working software is the primary measure of progress.
- Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
- Continuous attention to technical excellence and good design enhances agility.
- Simplicity--the art of maximizing the amount of work not done--is essential.
- The best architectures, requirements, and designs emerge from self-organizing teams.
- At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
A Time Before Agile: Waterfall Software Development
We’ve been mentioning how the old ways of software development are horribly obsolete today.
Now let’s take a quick look at the history of software development that Agile grew out of.
The fact is, if the founders didn’t invent Agile when they did, someone else would have.
Waterfall software development was the original model.
At the time, it was the pinnacle. The gold standard. Really, the only way of doing things.
It all started with the heavy documentation we mentioned earlier.
Long documents that detailed everything imaginable about the software.
After everything was documented, the development team would map out the architecture, data structure, nonfunctional requirements, etc. for the app being developed.
After all of this painstaking work upfront was completed, teams could finally start coding.
As you can imagine, this process took YEARS to complete.
And that’s how long a single app could take to develop before hitting the market.
The founders of Agile recognized this and realized the need for rapid software development and deployment. So they created the Agile principles and values.
How to Implement Agile in Your Business
Putting Agile into practice in your business won’t happen overnight. You probably know that.
It takes the dedication of your team, organizational leaders, and top executives to make a new software development model work consistently for you and your clients.
Getting everyone onboard isn’t easy when you’re doing it alone. That’s where we come in.
ATC specializes in Agile consulting. We can help you:
- Analyze your organization and its current processes and provide you with a roadmap and recommendations for adopting or improving Agile capabilities.
- Facilitate your organization’s transformation from legacy methods to a mix of Agile practices and principles to redesign processes, reinvent roles, and restructure incentives for optimal adaptability and performance.
- Scale the Agile system throughout your entire organization, codifying the framework and helping you implement and sustain Agile initiatives across multi-team projects and platforms.
Reach out today to discover how to make Agile finally work in your business.