This article is part of Overcoming JADC2 Software Challenges, a series of reflections on software...
This article is part of Overcoming JADC2 Software Challenges, a series of reflections on software challenges faced by the Joint All-Domain Command and Control initiative written by Tangram Flex’s CTO Matt Naveau.
In my first article, I talked about the importance of using a Modular Open System Approach (MOSA) for the US Department of Defense’s (DoD) Joint All-Domain Command and Control (JADC2) initiative. MOSA brings a significant advantage to the JADC2 system integration challenge by defining and standardizing interfaces. In practice, though, it can be challenging to adopt MOSA in “real world” systems. Fielded systems are typically not compatible with current MOSA standards. These “legacy systems” are critical to the success of JADC2 – it’s not practical to replace them all at once –, yet upgrading them to interact in a modern, MOSA-based environment is often time-consuming and expensive. For the JADC2 vision to be realized, it is imperative that MOSA adoption is accelerated for existing systems.
In order for two entities to understand each other, they need to have a shared understanding of how they will communicate. This article is written in American English. If you are reading and understanding this, you and I have a shared understanding of letters, words, and sentences. Not only do we have a shared understanding of the written language, but we’ve also agreed on a communication channel – I’ve published this article, and you are reading it. Like humans, computer systems have a similar need for shared understanding to communicate. They need to agree on both the “language” of communication as well as the “channel” of communication. Technically speaking, that means they must agree on things such as the hardware interface (how bits and bytes are moving), transportation protocols (how to group data into packages to make those bits and bytes meaningful), serialization (how to format data to fit into those transportation packages), the data format (the structure of the data), and the symantec intent of the data (what the data means). If any of these things do not match, the systems cannot communicate, in the same way that someone who could read only German paper newspapers would struggle to understand this American English article published electronically.
When upgrading a legacy DoD system to a modern MOSA standard, a big challenge is teaching the existing system a shared understanding of the new standard. Typically this means getting a team of software engineers to modify the code to add a new interface compatible with the new standard. Theoretically, that is straightforward to do, but in practice it is notoriously more difficult than it seems, often impacting the schedule and budget of programs much more than anticipated. At Tangram, we know of many stories of programs halting their forward progress of development to add support for a new MOSA standard. These program teams have felt the pain and difficulty of adopting new standards in both cost increases and delayed delivery. One program had to divert a dozen developers from adding new features to the software for their critical program for 4-5 months just to upgrade their interface software to a newer version of an open standard. That’s over 7000 labor hours worth of effort and nearly a half-year delay in capability to the warfighter. Nobody wants that, and JADC2 can’t succeed with these kinds of delays. When adding support for a MOSA standard is painful, programs may find ways to ‘opt out’ or to minimally incorporate the standard. For JADC2, this means that there will be systems that can’t connect to the MOSA-based JADC2 enterprise, which ultimately means less information for decision-makers and fewer options for connected command and control. Put another way, this means that the JADC2 vision is not met. We need MOSA upgrades, and we need to get the upgrades in place faster.
The main reason that MOSA upgrades to existing systems are challenging is the sheer number of details that have to match up for systems to communicate. Engineers must make sure that interfaces are compatible in every aspect of the software and hardware. A software component sending an aircraft’s location as streaming binary data is not directly compatible with a component receiving that location as XML data from a message queue, just like a sentence spoken in German is not automatically understood by an American English speaker. Working through all of these software integration details takes time. Depending on the complexity of the system, that time is measured in weeks or months. Also, with so many details to keep track of, it’s all too easy for human integrators to make mistakes.
Interface code generation tools offer great promise to help engineers with these challenges. These tools can manage the complexity of details and provide push-button options for integration with new standards. A good interface code generator makes a developer’s life easier with a variety of capabilities. Out-of-the-box tool options for MOSA adoption problems are a must, such as providing choices for what source code language is generated, which transport mechanisms are used, which serialization formats are available, and built-in support for a variety of standard MOSA formats. Also, the ability to give developers flexibility in specifying their new or custom MOSA data is important, both in basic features like specifying message fields and types and in advanced features like data inheritance and data constraints. This flexibility not only helps the developers when creating the first version of a system, it also enables them to react quickly as requirements evolve over the life of a program. A good interface code generation tool will create output that works without additional hand-coding, and the code it produces should look more like code written by a human than a machine. When an interface code generation tool can combine these characteristics, it simplifies the developer’s job and accelerates their ability to deliver MOSA upgrades in existing systems.
At Tangram Flex, we believe that code generation tools are an important part of realizing the large-scale MOSA upgrades required to achieve the JADC2 vision. Software development teams will adapt legacy systems to JADC2 environments more efficiently and cost-effectively with good tools to help them. This is why we’ve built the interface code generation capability in Tangram Pro’s Developer toolkit to manage complexity and give developers many ready-to-use options for integration. Before we worked at Tangram, many of us on the Tangram team have been those engineers who had to upgrade a legacy system by hand. We’ve made the code generation feature of our Developer toolkit the kind of tool we would want to use – high-quality output code, many configuration options, support for common MOSA standards, and an ever-growing list of flexible use cases and options. Our team at Tangram wants integration teams delivering high-quality, timely capability to the warfighter. This mission motivates us every day to keep us striving to make better tools that produce quality code.
We’ve been enhancing our code generation engine and applying it to real-world challenges for quite a while now, and we’ve learned the impact our code generation tool can make on real-world systems. Recently we partnered with an organization developing and sustaining software for Air Force systems. They needed to bring a new open architecture standard to a family of existing systems, and they had prepared themselves for a multi-month development effort. We gave them a trial account for Tangram Pro Developer and a link to our documentation, and within days they had produced the code library they had expected to develop over the course of months. Not only were they thrilled with the quality of the generated code, the flexibility to support changes to the standard and their systems in the future, and the “free forever” use of their outputs that help them avoid vendor lock, Tangram Pro reduced their development time from months to days. That’s an order of magnitude reduction in time and a significant acceleration of MOSA adoption. We are thrilled to see our Developer code generation tools make this kind of impact.
Adopting MOSA in legacy systems at the scale required by JADC2 will not be easy. In spite of what many contractors’ sales and marketing briefs might say, there is no magic answer to the problem. It takes a lot of hard work by a lot of engineers for integration. Yet, we can empower those engineers to move more quickly by giving them the right tools. Interface code generation tools in the hands of integration teams hold great promise to accelerate the process of MOSA adoption. It continues to be my hope that all of us working toward the JADC2 vision can pull together using the best technology available to achieve the vision as quickly and effectively as possible. If we do this right, together we will deliver critical capabilities to the warfighter in a timeframe that will make a noticeable impact.
