The world of modern software development is only a few decades old, and yet its evolutionary history is rich and complex. After years of experimenting with various development practices – some highly structured and disciplined, some far less so – much of the software development community has agreed upon best practices that help development teams deliver high-quality work quickly and sustainably. The resulting collection of best practices is referred to as Agile development, and it has transformed the way software is planned, executed, and delivered.
Agile teams deliver working, tested software every two weeks.
If you are new to Agile development, you might be surprised to hear that Agile teams deliver working, tested software every two weeks. If you're used to large, batched releases and traditional programming practices, this might seem hasty - but Agile tools like test-driven development, simple code design, and pair programming are designed to facilitate frequent, small releases that are high-quality and sustainable.
Relying on Agile development practices helps dev teams – and the code itself – stay agile. Agile practices add structure and accountability to the software development process, leading to scalable, low-defect code with simple, robust design. Agile teams move faster and with greater discipline than traditional software teams, creating code that is well-factored and well-protected by unit tests.
Read on to learn more about Agile development practices and how they can benefit your software teams.
In the late 1990s, it was becoming apparent that traditional software development practices were not fast or adaptable enough to effectively manage the workflows of development teams. Most of these methods were clunky, overly regulated, and highly micro-managed – creating poor environments for inspiring innovation or evolution.
Several lightweight software development methods emerged as a reaction to these cumbersome methods, including rapid application development (RAD), the unified process (UP), the dynamic systems development methods (DSDM), Scrum, extreme programming (XP), and feature-driven development. Today we know that what each of these methods was ultimately aiming for was Agile.
Individuals and interactions over processes and tools: The Agile development methodology emphasizes effective collaboration between competent people over overly complex processes and tools.
Working software over comprehensive documentation: A key element of Agile is frequent, iterative development – planning and producing work in small batches, and then testing that work in the market. As such, Agile methodology values working software – software that is able to be delivered to the market – over comprehensive documentation. Agile thinking is that good documentation is useful in helping people understand how a piece of software was built and how to use it, but ultimately the purpose of development is to create software (or in other disciplines, a functional product or service), not documentation.
Customer collaboration over contract negotiation: What determines whether a product or service is successful? Ultimately, it's whether the product or service meets the customer's needs. Agile methodology engages the voice of the customer in the development of products. It values active, frequent collaboration with customers to develop work that truly addresses real needs.
Responding to change over following a plan: Agile development methodology allows teams to deliver in small batches, frequently, with short planning cycles – so as plans change, teams can change with it.
In addition to these core values, Agile development teams use the following Agile practices to achieve greater flexibility, quality, and sustainability in their code: Test-driven development, code refactoring, continuous integration, simple code design, pair programming, a common codebase, the Agile coding standard, and collaborative workspaces.
Let's break each of these Agile development practices down to understand how they differ from traditional development practices.
For any software team, it's important to reduce the risk of defects where possible. Defects can slow teams down, hindering their ability to deliver work quickly and reliably. Testing code early and often can help mitigate the risks caused by defects.
Agile development encourages teams to produce automated tests for production code before writing the actual code.
Test-driven development is an Agile development practice that encourages teams to produce automated tests for production code before writing the actual code. For every small chunk of functionality in production code, teams first build and run a small, focused test that specifies and validates what the code will do. This helps Agile coding teams find potential defects or issues before they occur, in a systematic and organized way – drastically reducing defects.
Agile development teams maintain and extend their code drastically from iteration to iteration, so they need a way to clarify and simplify the design of existing code – without changing its behavior. Code refactoring is an Agile practice that can help expand the lifespan of useful systems, while reducing frustration and rework required of teams.
Traditional software methods don't dictate how frequently teams should integrate source code on projects, so it's quite common for developers to work separately for hours, days, or even weeks on the same source code without integrating it. Infrequent integration leads to conflicts that require extensive time to debug.
For this reason, Agile teams choose to use Continuous Integration. Continuous Integration (CI) involves producing a clean build of the system several times per day – reducing the risk of bugs and conflicts.
Agile development teams focus on increasing the extensibility of their code (the extent to which they can maintain and extend it) to remain as flexible – agile – as possible. Code refactoring is one way of keeping code extensible – another is simple code design. The simpler and cleaner code design is, the more extensible and, and therefore Agile, it becomes.
Pair programming is another Agile method for systematically improving the quality of code. Pair programming involves having two developers working together at a single station. While one drives (operates the keyboard), another navigates – observing, learning, asking questions, and making suggestions. Pair programming can result in better designs, fewer bugs, and better knowledge sharing across the team – improving both short- and long-term productivity.
Pair programming involves having two developers working together at a single station.
This Agile software development practice is conceptually quite simple: A common codebase is a codebase shared by as many people on the team as possible. This is, of course, only practical if the team is using test-first programming, code refactoring, continuous integration, and a single coding standard. Pair programming can also be helpful in reinforcing the common codebase.
When all the developers on a team adhere to a single coding standard, it's easier to maintain code, refactor it, and reconcile integration conflicts. A shared, single coding standard – including everything from tabs vs. spaces and curly bracket placement to naming conventions for things like classes, methods, and interfaces – can help the entire system operate more smoothly.
Finally, a shared, open, collaborative workspace is a critical element of Agile software development. An open environment facilitates team communication, helping teams stay on process and focused on delivering business value. A collaborative workspace gives teams lots of facetime, encouraging stronger working relationships, more effective collaboration, and higher job satisfaction in teams.