Second generation Agile Engineering Practices - codecentric AG Blog
The world does not stay still. After the successes of Agile Methods at the end of 90th and start of 2000 their application has grown dramatically. Also their areas of applicability have extended far beyond initial sweet spots.
One of additions is the usage of agile practices to working with databases. This concerns work on automating DB schemas changes and on testing and refactoring databases.
FDD Approach to building domain models has found its further expression in Domain Driven Design (a.k.a. DDD). Although one cannot state that DDD is a direct successor of FDD Color Modeling/Streamlined object modeling approach, but Streamlined Object Modeling is widely recognized and highly regarded in DDD community.
Unit and Acceptance Testing
Test Driven Development was further developed into the Behavior Driven Development (BDD). The main difference between two is the language used for expressing requirements. This language produces sometimes more readable specifications. As well BDD, compared with unit tests, is usually used for testing at higher levels.
Two distinct styles of unit testing appeared. These are state-based testing and interaction-based testing. The second style relies heavily on mocks.
Community currently experiments with another unit testing style – property based testing, which has its roots in Haskell QuickChecks framework. In property-based tests, the same test is run over and over with generated input.
Another development was the adaptation of agile engineering practices for working with legacy code. This has led to understanding that unit testing in certain scenarios is really complicated.
Three of such scenarios are unit testing legacy code, writing unit tests for GUI and testing asynchronous code.
The techniques of Automated Acceptance Testing were developed further. The practice was further refined as “Specification by example”. Many different acceptance testing frameworks were developed besides original Fit & Fitnesse. At the same time this practice still remains one of the most controversial in agile software development. Drawbacks of the automated acceptance testing became better understood. Manual testing has made its comeback in the form of exploratory testing.
Code Reviews and Static Code Checking
Several good systems for performing distributed code reviews have appeared. To them belong Code Collaborator, Crucible, Review Board and other. They have allowed reducing the overhead of heavy-weight formal inspections.
Usage of static code checking tools has been extended to code quality monitoring platforms. They gather together results of application of various code checkers in a dashboard. One can drill-down dashboard and explore details. This allows ongoing source code quality monitoring. SonarQube is an example of such a platform.
The experience has shown that the Continuous Integration is one of the most valuable Agile Practices.
It was extended in two directions.
The practice of running tests on each commit was brought to individual developers’ level. The tools of continuous testing now allow running tests and performing static code checks on every save operation.
Continuous Deployment and Delivery
The need for frequent releases requires going beyond continuous integration. Propagation of new releases into another environment in best case should be a one button operation. Thus deployment automation was born.
Deployment automation is as well tightly coupled with the need to be able to reproduce environments easily and deploy solution to several identical nodes. This is often required when developing cloud-based solutions. This has led to proliferation of tools for virtualization, automated virtual machine provisioning and configuration.
When performing a lot of environment changes, one should be able to detect problems on these environments fast. So, solutions for runtime monitoring are now widely used.
Also short cycle from development to production has increased the need in automated performance testing.
The set of the interrelated practices for automated deployment, environment creation, provisioning, configuration and monitoring are now united under the hood of Continuous Deployment.
Our review would not be full without mentioning social movements in the software development.
The mindset of doing a quality work and set of good practices for developing easily maintainable solutions has found its expression in the Software Craftsmanship movement.
Implementing Continuous Deployment has turn out to be not only technical, but even more a social process. It requires frequent interaction, collaboration and integration between software development and ops people. This need is expressed by “DevOps” movement. It aims to help an organization rapidly produce software products and services.
Would you like to exchange experience about individual practices? Would you like to share your war stories? Then visit the next 14. Agile Stammtisch Frankfurt on 4th of September, where one can discuss all the questions related to agility.
The topic of the lightning talk would be “Agility and Databases“