Organizations undergoing a digital transformation must proactively address the changing needs of their business and stakeholders by adopting modern software development processes, leveraging new technologies, and following innovative business models.
These organizations typically start with adopting agile practices for managing requirements and deliverables in an iterative way. The focus is on bringing transparency, creating a culture of communication and collaboration, and soliciting frequent feedback from stakeholders to drive continuous process improvement.
Improving these aspects of your process is good, as it makes teams more effective and efficient. However, proper attention must also be given to technical excellence, or else your improvement results will lag behind expectations. A lack of focus on technical excellence leads to inefficiencies in the development process, including quality challenges that jeopardize the ability to deliver working code; code merging issues that take a lot of time and effort to fix; needless complexity, rigidity, and viscosity in the design; release management and deployment issues; and improper data modeling for functional validation and simulation.
To help teams avoid these issues, it is important to have them focus on performing continuous planning and engineering activities, all the way from envisioning business requirements to application deployment into production. While many teams now focus on implementing continuous integration and continuous delivery practices, they fail to embrace continuous planning and other engineering practices such as continuous design, proper branching and merging strategies, continuous data management, and continuous testing during the release management process.
Constant attention to technical excellence and good design is an agile principle that cannot be ignored. Let’s take a deeper dive into these continuous engineering areas.
Continuous Attention to Design
Giving continuous attention to design is important because it keeps your design and code simple, clean, and as expressive as possible. It also helps the team avoid factors that lead to bad design: rigidity (where designs are difficult to change), fragility (where small changes cause unexpected errors elsewhere), and immobility (where designs are difficult to reuse).
Continuous attention to design also assures that teams take every opportunity to improve the design through refactoring. It involves intensive and constant review and commitment to continuously evaluating and improving the design. If a design flaw is identified during the user story development process, it should be immediately fixed. The goal of this process is to make objects and components cohesive, decoupled, and as simple and explicit as possible.
Branching and Merging Strategies
Software configuration management and branching and merging strategies help maintain software versions and track changes during development and delivery activities. Having a sound strategy and set of practices keeps teams from dealing with constant code conflicts or confusion over which changes are in which build.
The team should define up front a suitable workflow strategy for managing branches and maintaining versioning during development and continuous integration activities. Depending on your preference, your branch and merge strategy could be centralized workflow, feature branch workflow, Gitflow workflow, or forking workflow, based on what best suits your application delivery process and the nature of your projects.
Continuous Data Management
Data management is critical when creating data-oriented architectures, validating data policies, and supporting the development and testing process for data intensive applications.
QA professionals usually have access to good test management tools but are not given the same access to data management capabilities. This is often due to various constraints surrounding the use of production data for testing or difficulties in creating data sets that mimic production data. Making sure required data is available for testing and validation during development and delivery is critical to continuous testing and delivery processes.
In addition, the team has to continuously improve data quality through database testing and refactoring, evolve its testing process when data assets change (such as test data, lookup data, master data, or metadata); and have mechanisms in place for data governance, as applicable.
Continuous Testing and Automation
There are many challenges teams undergo in agile projects to deliver working features during sprints. One of the biggest is removing the barrier that often exists between development and testing.
This barrier leads to testing issues that impact quality: no consensus on a test strategy, testing requirements and test environment setup not being made enough of a priority by the team, regression testing suites that not properly maintained, not enough time to automate functional tests, and not enough time to complete testing during sprints. All these issues impact the ability of the team to integrate testing into continuous integration and delivery processes, slowing down code deployment, too.
Luckily, there are some recommendations for addressing these challenges.
First, automate functional test cases during the sprint and build up your regression suite incrementally. The ability to regression test each change is an essential part of successfully implementing agile. Completing necessary automation should be defined as part of your definition of done for each user story and should be done during test development.
Create story tests that map to user story acceptance criteria. Ideally these test cases are specified prior to story implementation so the developer can use them as specifications for how the software should behave. Functional testing must also include system integration tests that test the integration of stories and end-to-end scenarios and use cases as they are implemented.
Acceptance tests and regressions tests also must be integrated into your continuous integration and delivery pipeline so continuous testing can identify defects as early as possible in the delivery process.
Leveraging behavioral-driven development (BDD) is one agile practice that helps achieve the above recommendations. BDD practitioners spend time discussing the desired behavior of a unit, story, or use case and create examples that provide clarity on what is being implemented. BDD derives scenarios from these conversations that ultimately can be captured and automated, assuring that tests are created early and often during sprints.
Automation in the Release Management and Deployment Process
Release management involves lots of coordination among stakeholders, testers, and your go-live team, preparation for post-production deployment management, verifying activity logs, and preparing to address initial operational issues. The main challenge in these processes is making sure the entire delivery team is on the same page and follows the organization’s governance model.
The automated delivery pipeline and appropriate quality gates also have to be well defined. Here are some recommended practices:
- Implementing standardized tools to automate release management workflow, checks and balances, approvals, and acceptance by key stakeholders
- Applying infrastructure as code concepts for managing environment configuration and infrastructure to accelerate the delivery process and reduce manual errors
- Creating a round-trip, integrated tooling ecosystem—i.e., integration of business activity monitoring tools with incident and problem management tools to provide insights for the business and development, as well as integrated knowledge management tools with the continuous delivery tools, in order to provide a closed loop process for automated delivery and quick remediation of production issues
Building an Agile Engineering Culture
While not a specific agile engineering practice, aligning cultural elements is also necessary to growing and optimizing an engineering culture. By this I mean giving prominence to people, trust, and innovation.
Adhering to lean philosophy is the key for building such a culture. There are three principles that need continuous reinforcement to sustain an engineering culture:
- Teams are allowed to be autonomous yet still align with business objectives
- Teams are encouraged to focus on value delivery rather than completion of a plan
- Members share and spread knowledge and lessons from mistakes through storytelling, community of practice, and pairing
Organizations undergoing a digital transformation must adopt new and meaningful ways of working. For transformations to be successful, teams must leverage agile engineering techniques and models in addition to agile processes. Continuous focus on the agile engineering areas discussed in this article will provide a solid ground for teams to enhance their agility and deliver better software, faster.