The word “agile” has been around for many decades. It might not be a word people typically use on a daily basis, but it’s one most are familiar with. And over the years, it’s a word that’s become synonymous with software development – thanks to a massive and profound movement that’s become a fundamental component of the industry.
If you look up the definition of agile, the first explanation reads “able to move quickly and easily.” The second definition, however, defines agile as a word “relating to or denoting a method of project management, used especially for software development, that is characterized by the division of tasks into short phases of work and frequent reassessment and adaptation of plans.”
Everyone in the industry knows what agile software development is. But if you’re on the peripheries of the industry, you’re probably looking for some additional clarity. In this article, we’ll walk you through exactly what it is, the foundational principles it’s based on, the different types of methodologies used, and how you can work with us to put agile software development to use for your next piece of software.
Agile software development is essentially an umbrella term for a collection of frameworks and practices that are based on distinct principles and values that are outlined in the Manifesto for Agile Software Development and the underlying 12 Principles that support it.
The Agile Manifesto first began surfacing in developer communities around 2001. Its goal was to upheave and transform the rigid software development process that had existed until then.
Throughout the 1990s, software development was marked by a huge time lag between business requirements (the various features customers were requesting) and actually delivering the technology needed to satisfy these needs and wants. This led to tons of cancelled projects, lots of unhappiness between developers and clients, and a lack of profound innovation in industries and spaces that needed it most.
The old process would typically work like this: A business would request a piece of software with certain requirements. The developer would take many months to make progress. And by the time the developer was almost finished, customer prerequisites had already changed. This meant the final product no longer met the current needs of the user. So the process would start all over again.
This is what the industry looked like for years. It was characterized by friction and frustration on both sides. And then in 2000, a group of 17 of the brightest minds and thought leaders in the industry – including the likes of Kent Back, Jon Kern, Alistair Cockburn, Aerie van Bennekum, and Ward Cunningham – met at a resort in Oregon to discuss a new approach. Then they met again in 2001, this time at The Lodge at Snowbird ski resort in Utah. And it was during this later meeting that they formally drafted the Agile Manifesto and 12 Principles of Agile Software.
The objective of the Agile Manifesto is to uncover superior methods of development software. And as the four values of the Manifesto read:
In other words, agile means adding value through efficient people-first processes that minimize friction and drive positive results.
Those behind the Agile Manifesto knew that the four values wouldn’t be enough to enact sweeping change in an industry filled with stubborn figures. So they decided to offer more concrete examples of what agile development should look like in practice. They came up with a dozen principles:
1. Our highest priority is to satisfy the customer through early and continuous delivery of valuable software.
It’s far better to deliver software at short and regular intervals, rather than waiting until you have a finalized product to submit. In other words, agile principles say you should deliver software in phases – ideally every couple of weeks – so that the customer is satisfied and iterations can be made early and often.
2. Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage.
Always think through the lens of the customer. They want what’s best for their end user. When there is evolution on the side of the end user, there needs to be some evolution in the software to meet these changing requirements. The beauty of following the first principle is that you can typically make these changes in process. This avoids delays and speeds up the delivery.
3. Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale.
This principle ties in with the first one. By releasing small versions of the software at a time, there are fewer chances of bugs. There’s also more time to garner and implement customer feedback.
4. Business people and developers must work together daily throughout the project.
Traditionally, software developers are insulated from the client. There are analysts or salespeople that go in between and translate for both parties. However, this extra layer only slows down the process and increases the likelihood of misunderstandings. Agile development calls for direct interactions between developer and client. As a result, misunderstandings are caught earlier on and regular feedback produces superior outcomes.
5. Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
This principle speaks to building a team of developers who are fully prepared and equipped to develop quality software that adds value to the client and end user. It emphasizes the importance of hiring developers you can trust and don’t have to micromanage. (And in most cases, this means hiring motivated people who want to succeed.)
6. The most efficient and effective method of conveying information to and within a development team is face-to-face conversation.
Alistair Cockburn was the driving force behind this principle (and he was way ahead of his time). The idea is that developers and clients need to directly interact with one another in order to move a project along. Face-to-face conversations are always preferred, but in cases where this can’t be done, live video conferencing is a good option. This is followed by phone/audio. Email conversations are not preferred, except for the simplest updates and requests.
7. Working software is the primary measure of progress.
Mockups, wireframes, models, and plans are great, but they don’t mean anything. The only way to measure progress is to analyze the working software. And software isn’t finished until it’s been delivered and released. Until then, it’s just an idea or piece of inventory.
8. Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Some degree of predictability – a cadence, if you will – is necessary in order for the software development process to go smoothly. It’s helpful to establish a repeatable and maintainable speed of delivery early on. This helps both parties understand the progress that’s being made.
9. Continuous attention to technical excellence and good design enhances agility.
Though speed to completion (time-to-market) is often the primary objective for a business, it’s also important to consider technical excellence and good design. A failure to account for these elements will lower the quality of the software and limit its shelf life (meaning another solution will quickly surpass it).
10. Simplicity–the art of maximizing the amount of work not done–is essential.
This looks like eliminating procedures that aren’t relevant any longer, automating time-consuming manual work, utilizing existing libraries instead of developing custom libraries from scratch, etc.
11. The best architectures, requirements, and designs emerge from self-organizing teams.
This principle is based on a combination of other principles outlined above. It’s rooted in the belief that the best teams consist of highly motivated individuals that are given freedom from above to carry out their tasks via modes and processes that prioritize speed and value.
12. At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.
No matter how closely a team follows these 12 principles, or how skilled individual developers may be, it’s imperative that there are regular periods of reflection and optimization. Agile teams aren’t perfect – they just identify mistakes earlier and iterate faster.
Over the past decade, “agile” has bordered on becoming a buzzword. A lot of software developers – and even businesses outside of the software space – will claim they “do agile.” However, most of these companies merely pay lip service to it.
You can tell a lot about where a developer’s true focus is by analyzing their work through the lens of the aforementioned 12 principles. You can also get a feel for how they implement this philosophy by inquiring about the different agile software development methodologies they use.
Here’s a look at some of the primary agile methodologies and what they look like in practice:
1. Agile Scrum Methodology
The Scrum project management methodology is one of the most common. It’s popular amongst developers and clients alike because it’s incredibly simple and prioritizes productivity at every stage, unlike waterfall project management which is sequential. It involves creating a “product backlog” and then conducting “sprints” (which typically last for 30 days) to tackle each item in the backlog.
People love the Kanban method because it’s simple and highly visual. It allows you to see the workflow and manage it in an intuitive manner. Kanban is based on three primary principles: (1) Visualize what you’ll do today, (2) Limit the amount of work in progress, and (3) Enhance flow (when something is finished, pull out the next highest priority item and put it into play).
3. Lean Software Development
This iterative methodology emphasizes delivery value to each customer though value stream mapping. It’s known for being flexible and doesn’t force the developer into a rigid set of guidelines and rules. The main principles of the lean methodology include eliminating waste, amplifying learning, deciding as late as possible, delivery as fast as possible, empowering the team, building integrity, and seeing the whole.
4. Extreme Programming
Known by the acronym XP, Extreme Programming is a disciplined approach that focuses on speed and continuous delivery. It’s intended to improve the quality of software in spite of changing customer requirements. It’s great for situations where there are lots of dynamic factors in play and feedback is constant.
Many agile methodologies have lots of requirements and steps. And while they’re all well-intentioned and designed to improve efficiency, speed, and value, they can take a while to learn. The Crystal methodology is, by contrast, extremely lightweight. It emphasizes people and processes, allowing for regular iterations and frequent adjustments.
6. Feature-Driven Development
Feature-Driven Development, or FDD, is a model-driven, short-iteration process that starts with establishing a model shape and then continues with two-week series of “design by feature, build by feature” iterations. This method is often preferred when there are large teams and a need to scale up quickly without getting bogged down in individual features.
7. Dynamic Systems Development Method
This method, referred to as DSDM, is intended to provide a comprehensive foundation for planning, managing, executing, and scaling the agile process. It’s based on eight key principles, each of which is intended to direct the team and cultivate a mindset of delivering on time and under budget. These eight key principles are: (1) Focus on the business need, (2) Deliver on time, (3) Collaborate, (4) Never compromise quality, (5) Build incrementally from firm foundations, (6) Develop iteratively, (7) Communicate continuously and clearly, and (8) Demonstrate control.
Quality software doesn’t arise by chance. You don’t go from an idea to a fully functional solution that addresses an end user’s needs without careful planning and execution. Agile software development attempts to minimize friction and maximize efficiency through a set of universal principles that free developers up to follow their own preferred methodology.
If you’re looking for a software development team that understands and embraces agile development, we’re here to help. At Dev.co, we believe in agile methodologies and following the 12 principles outlined in this article.
Want to find out more about how we work and what sort of value we can add to your business or venture? Please contact us today and we’ll be happy to chat about it!
Ryan is the VP of Operations for DEV.co. He brings over a decade of experience in managing custom website and software development projects for clients small and large, managing internal and external teams on meeting and exceeding client expectations–delivering projects on-time and within budget requirements. Ryan is based in El Paso, Texas.