Use Version Control to Unlock Your Development Velocity

Version control is an important capability that allows developers to safeguard their source code while simultaneously providing information valuable to improving development velocity.

Some people think of version control as being simply “check in” and “check out,” but that is only the beginning. Effective source code management provides a basis for every other essential development best practice, including continuous integration and continuous delivery. The key is realizing just how much valuable metadata is being created in your source code management system and establishing the tools and procedures to make this information available as needed. Here’s how to use version control to unlock your development velocity.

By organizing your work into discrete development components, robust source code management solutions provide a comprehensive platform upon which to model your software architecture. You may be modeling code components on multiple platforms, including mainframe, Linux, Unix, and Windows, and you may be working with different technologies, from Java to C# and .net. With the appropriate tools, you can use code patterns, such as feature branches or bug fixes, to manage the concurrent development efforts of many developers.

Without these robust tools, it would be difficult (or perhaps impossible) to manage code variants and distributed development, such as when you have one team working in the United States and another team in Europe or the Middle East. When your India-based team goes offline at the end of their workday, your source code management system provides a way to see exactly what changed and how that might impact what your team in New York needs to complete by the end of their day. Many people do not realize the extent to which your version control system becomes your single source of information for your entire development process.

Your version control solution provides a treasure trove of information, including when a specific line of code was modified for the first time, who made that change, and, specifically, the modification itself. With task-based development, you can link a defect description to the change set that contains that modification. The metadata associated with this change provides valuable information that can help guide the development effort. This information can be particularly useful for full traceability and compliance with the audit and regulatory requirements common in many industries.

Based on my experience of creating ClearCase add-on tools for almost a decade, here are some specific examples of how the information found in the metadata of robust source management systems can be utilized.

Impact analysis allows you to examine a bug on a specific line and then link this line to a release baseline using a version label or tag. The baselined code can be linked to a release version or even a specific customer requirement, enabling the development team to provide customized solutions to support unique customer requirements. When you need to make a change to that code, you can elegantly retrieve the complete code baseline based on the label or tag and make the necessary modifications, without the risk of the code regressing due to the wrong version of a configuration file or other dependency.

Version control systems help identify exactly how many code lines have been changed on a certain release, which is really useful when automating tasks such as code reviews and automated builds. Many developers also use version control tools to identify potential merge conflicts through continuous integration. Savvy development managers will use this robust information to monitor the pulse of the entire software and systems development effort.

The best version control solutions provide extensive transparency and traceability. This means you can identify and support developers who are struggling with a particular code change, providing a methodology for other colleagues to help review changes and suggest better ways to address the issue. Version control tools exist within an ecosystem of other products, most importantly the continuous integration (CI) server. CI servers can automatically trigger the application build, package, and deployment from a code commit. The code baseline can then be pushed to a test environment where code scanners can be used to identify potential code quality, and even security issues, such as when a developer hardcodes a password directly in the source code or a visible configuration file.

Version control also supports application lifecycle management (ALM). ALM includes many stakeholders, from those who create requirements documents to the testers. Robust version control solutions can safeguard all the essential artifacts and ensure that they are kept aligned with their specific targeted release or bug fix. This means your version control system can be used by every stakeholder on your team. These techniques also support the iterative nature of agile development and enhance developer velocity.

Using version control effectively is particularly important when you are creating the automated deployment pipeline. Building the automated deployment pipeline relies heavily on the version control system to safeguard all the automated scripts and the configuration items they build, package, and deploy. These procedures enable continuous integration and continuous delivery, which is especially important when you need to integrate the work from multiple teams, each responsible for a specific component.

While it’s important to keep up to date with advanced techniques in software development, it is always a good idea to take a step back and understand the basic core techniques that support development velocity. If your IT team implements version control successfully, it will be able to excel at agile development and DevOps.