The DevOps Toolchain & Automating Code Mapping Within Your Dev Process
The DevOps Toolchain & Automating Code Mapping Within Your Dev Process
Developers are no strangers to working quickly, but they also have to deliver quality code while maintaining velocity.
It’s a fine line to walk and is why devs employ a range of automation tools to support how they build, test, and deploy software.
Along with being effective for development, these tools also have to provide value across teams, meaning that both Dev and Ops teams will adopt them in an effort to improve communication and collaboration. In short, the tools in the DevOps toolchain are the grease that reduces the friction between teams that want to move fast and deploy software quickly and those that value moving at a slower pace to ensure safety and mitigate risk.
By integrating automated code mapping tools into the development process, companies gain a very powerful capability to ensure Dev and Ops teams are always on the same page and aligned in their efforts to achieve business goals.
CALMS DevOps Framework and How Code Mapping Fits In
The CALMS framework stands for Culture, Automation, Lean, Measurement, and Sharing. This framework serves as a way for companies to assess when they’re ready to adopt DevOps practices and gauge how successful their DevOps adoption is.
Automated code mapping is all about providing visibility and documentation in software applications. Code mapping illustrates the hidden connections and dependencies between the code classes, methods, and databases that underpin an application – in other words, application intelligence. Code mapping and application intelligence go hand-in-hand with the CALMS framework. How? We explain below.
Application intelligence breaks down team silos. The ability to map code and automatically create documentation that visualizes how everything in the app fits together gets everyone—Dev, Ops, and other IT stakeholders— on the same page. This facilitates cross-functional communication and allows teams to better collaborate when making important decisions that affect an application database(s).
This part of the CALMS framework is all about automating as many manual tasks as possible. With the adoption of Agile, which values working software over comprehensive documentation, the manual process of documenting code changes often falls by the wayside. Similar to the automation capabilities centered around continuous integration and continuous delivery (CI/CD) – automated code mapping enables continuous documentation and alleviates the burden of manual work that is not Agile or DevOps friendly.
In the absence of automated code mapping, organizations are left to figure out what’s in their code and how it fits together the hard way. Traditionally, a lot of people, time, and money are required to create a static application map, and it’s already outdated almost the instant it is finished. This runs completely counter to the Lean principles of eliminating waste, minimizing WIP, making work visible, reducing hand-off complexity, and optimizing the value stream. Code mapping automation eliminates the inefficient and laborious task of crawling through code to map how it fits together. With the right mapping tool, this task can be executed on a schedule, on-demand, or any time a build is complete, ensuring teams always have an updated view of their applications.
Measurement refers to collecting data in order to determine where improvement can be achieved. Code mapping allows teams to visualize data and collect intelligence that illustrates where code complexity and technical debt exist in their application. When these insights are combined with a clear understanding of application connections and dependencies, teams are able to quickly identify areas for improvement, assess work scope and risk, prioritize projects, and chart a path for execution.
The final part of the CALMS framework focuses on creating a culture of openness and sharing within and between teams. Sharing keeps everyone working toward the same goals and eases friction when issues arise. Automated code mapping makes it easy to share important insight about application dependencies and database connections with engineering, SRE, and testing teams — ultimately enabling buy-in across the organization, and ensuring alignment on projects and goals.
How Code Mapping Fits into the DevOps Diagram and Toolchain
A typical DevOps toolchain is made up of dozens of tools. Each tool is designed to play a role in one or more of the stages of the continuous delivery process – from planning and building to testing and deployment, all the way through monitoring.
Much like the other tools in the DevOps toolchain, code mapping has an important role to play as well. These are the ways that code mapping ties into the DevOps toolchain.
Planning sets the precedent and groundwork for an entire project; if errors are made during this phase, there’s a higher risk of them being carried into other areas and maximized.
Code mapping ensures that developers in the planning stage can make swift decisions about whether to re-architect or rewrite code, rather than wasting time or skipping the consideration completely.
Engineers are sometimes asked to begin building new features without really knowing much about the code they’re working with, which can lead to uncertainty about the impact the code change will have on the rest of the application.
Code mapping gives developers a breakdown of code dependencies before they make any changes. As a result, teams can understand how their change will work with the rest of the application and be confident the update will perform as intended.
For many organizations, new application builds are happening by the minute (even seconds). That means developer documentation can become out of date just as fast.
Automating the delivery of new code maps after every build ensures developer documentation is always up-to-date.
Testing is all well and good if the QA team knows what they should be testing. Application code has become so complex it’s tough to know what parts of an app are being affected by a change. This lack of visibility means test case coverage can either be too broad in an effort to test everything or be too narrow if the team doesn’t understand what other parts of the app are impacted by the change.
Code mapping helps ensure test case coverage addresses all the classes, methods, and database items impacted by the code changes being built. By mapping the application code, testers can be confident they are running the right test cases and deliver better results for the business.
Release, Deploy, Operate
It can be challenging to know when to release all of an application versus releasing only a single service. Instead of going back and forth between the two options or making a rushed decision, automated code mapping can confirm when the code is set for release in its entirety. Similarly, code mapping can aid teams in knowing if all parts of the code are prepped for release or if other areas need revisiting.
Sending a product to market isn’t the end of development. Application teams are always eager to identify and address technical debt.
Code mapping is a great way to uncover hidden technical debt. Mapping code exposes each connection and dependency from class, to method, to database, making it easier to monitor and see problem areas such as which database tables and columns are being overused and which are not being used at all. Addressing these areas will help eliminate technical debt and improve application performance.
Code mapping tools are a great fit inside the DevOps toolchain. Automated code mapping fills common gaps that have been created by the adoption of other tools in the chain — tools that help teams build, test, and deploy new code fast. Application intelligence delivered by automated code mapping informs important decisions throughout the continuous delivery process and ultimately helps to ensure that quality, agility, and speed are fully in the loop.
Learn more about why companies are mapping their code. Read our white paper: Top 6 Reasons to Map Your Code.