Coding and Engineering in Agile
If you are new to Agile, 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 teams use planning, testing, and management tools like test-driven development, simple code design, and pair programming to move quickly and sustainably.
Why do Agile teams work this way? Using Agile practices in coding and engineering helps teams - and the code itself - stay agile. Agile practices add structure and accountability to the coding and engineering 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 to learn more about Agile programming practices and how they can benefit your software teams.
Coding and Engineering in Agile: Common Practices
Agile programming teams use the following core Agile practices to achieve greater flexibility, quality, and sustainability in their code:
- Test-Driven Development
- Code Refactoring
- Continuous Integration
- Simple Code Design
- Pair Programming
- Common Codebase
- Agile Coding Standard
- Collaborative Workspace
Defects can slow teams down considerably, so it’s important to reduce the risk of them where possible. Testing code early and often can help mitigate the risks caused by defects. However, many teams write tests after the code is written, or not at all, making it harder to make necessary changes - and more likely that code will need changes in the first place.
Test-driven development is an Agile programming 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.
Since Agile programming teams maintain and extend their code significantly from iteration to iteration, 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.
In traditional software development, programmers can work separately for hours, days, or even weeks on the same source code without integrating it. This is because traditional software methods don’t dictate how frequently teams should integrate source code on projects. 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. Agile teams typically configure CI to include automated compilation, unit test execution, and source control integration.
Simple Code Design
Agile teams push themselves to deliver working, tested code at the end of each iteration, while also being available to their customers to change requirements as needed. For this reason, Agile programming teams focus on increasing the extensibility of their code (the extent to which they can maintain and extend it). 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.
Another way Agile teams aim to improve the quality of their code is through pair programming. Pair programming involves having two programmers working together at a single station. While one programmer 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.
This Agile practice is as simple in concept as it sounds: 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.
This is helpful not only for improving quality and productivity, but it can also shelter teams against vulnerability to staff turnover: If everyone is familiar with a shared codebase, the team can quickly fill in the gap if someone leaves.
Agile Coding Standard
When all the programmers on a team adhere to a single coding standard, it’s easier to maintain code, to refactor it, and to 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 everything work better.
Finally, a shared, open, collaborative workspace is a critical element of coding and Agile engineering. This type of 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.
To learn more about coding and Agile engineering, we recommend the following resources: