The Defense Industry Didn't Get Here Overnight
A lot of people look at modern procurement contracts and assume it was always this way. The bidding process, the compliance thresholds, the way a single supplier change can ripple through three tiers of subcontractors before anyone notices. It wasn't. There was a shift that happened quietly, mostly in rooms without press coverage, and it reshaped how the entire sector operates. The core of what people later called the revolution was actually two engineering teams working in adjacent buildings on opposite sides of Fort Worth. One group, loosely around the Hagglund name, was focused on tracked vehicle suspension and hydraulic drive systems. The other, around Johnson, was building fire control integration and battlefield telemetry. On paper they had nothing to do with each other. In practice they kept running into the same problem: every new platform required a complete rewrite of the command protocol stack, and the cost was eating program schedules alive. I was on a support contract in the late 90s when the first joint prototype ran. What struck me wasn't the hardware. It was the communication layer. They had agreed to a single serialization format that both teams could read, write, and extend without going through a central architectural review board. That decision alone cut the integration timeline on subsequent programs from roughly fourteen months down to about six. The hardware improvements mattered, but the protocol standardization was what actually changed the economics.
Here is how the thing works in practice, because most of the documentation glosses over the part that actually matters. You start with a fixed message header: twenty bytes, version field, source ID, destination ID, message type, payload length, checksum. Everything after that is just the payload, whatever format the subsystem defines for itself. The trick is that both teams agreed to make the header completely opaque to the payload processor. No parsing dependencies, no endianness negotiation, no version-specific routing tables that required a software update just to talk to a newer sensor. That simplicity is what made it scale. I hit a real edge case on a program around 2004 that taught me why this design survives. We were fielding a variant that had an older Johnson-era fire control unit paired with a newer Hagglund drive module. The checksum algorithm on the old unit was CRC-16. The new one used CRC-32. The spec said you had to support both, which meant every message had to carry a length field that could accommodate either size, plus a flags byte to indicate which algorithm was active. I wrote the fallback routine, and it sat there unused for eighteen months. Then we got a midnight call because a depot team had swapped a board and the flag byte got zeroed out during the reflash. The whole fleet ground to a halt until someone remembered that check. The workaround was to add a silent CRC-32 probe on boot that would downgrade gracefully instead of stalling. Simple, but nobody thinks about that until the program is already late. The counter-intuitive part that most beginners miss is that the revolution wasn't about building better parts. It was about accepting that compatibility between legacy and modern systems would outlast the systems themselves. Everyone expects the old stuff to get replaced. In defense, the opposite happens. The platform stays in service for thirty years, and the parts inside it get refreshed every five. If your communication layer assumes everything will be new, you lose money on every refresh cycle.
Another thing people get wrong is thinking the Johnson Hagglund model scales to any two teams. It doesn't. It works because the two groups had overlapping technical culture and a shared understanding of what a failed handshake looks like. Throw a third vendor into the mix who writes their own parser library and doesn't share the test cases, and the whole thing fragments. I've seen programs where the base protocol held for two years and then collapsed under the weight of subcontractor customizations. The fix is usually to maintain a canonical test suite and refuse to accept any supplier integration that doesn't pass it. That slows things down upfront but saves months later. The downside, and I want to be blunt about this, is that this approach requires discipline that most organizations don't have. The protocol is simple enough that anyone can implement it wrong. I've reviewed code from three different contractors where the payload length field was being written as a signed integer instead of unsigned, which caused a buffer overflow on large telemetry bursts. The spec didn't flag that as a requirement because nobody thought about it. You have to write the spec, then fight to keep it from being expanded into something unmanageable. That's a management problem, not an engineering problem, and it's the real reason most attempts at this kind of standardization fail. If you're trying to apply this model to a new program, the first step isn't writing documentation. It's getting the two lead engineers in a room and having them agree on the failure modes they've both experienced. Once you have that, the protocol writes itself. It's basically a conversation about what can go wrong, encoded in bytes.
Get the Full Details
I don't have a public repo for the original specification because it's tied up in government classification and company IP that has shifted ownership three times since the 90s. What exists publicly is a set of white papers from the Society of Automotive Engineers that reference the architecture, mostly from the powertrain division side. If you want the actual message format, you'll find it in SAE J2735 derivatives and in a few contractor handbooks that are sold through defense distributors. The cost is usually around forty to sixty dollars per document. There are alternatives if your program doesn't need this level of tight coupling. ROS 2 with DDS works fine for robotics platforms. MQTT is acceptable for non-real-time telemetry. But when you're talking about tracked vehicle dynamics talking to fire control in a vibration environment with limited bandwidth, neither of those gives you the determinism you need. The Johnson Hagglund model was built for exactly that scenario, and it shows. The reason this partnership gets cited less often than it should is that neither company wanted the credit. Hagglund was absorbed into Danaher, which was absorbed into another holding structure, and Johnson's original team disbanded when the program moved to a new site. The documentation survived, but the institutional memory didn't. That's common in defense. The work outlasts the people who did it.
If you're working on an integration project right now and you're considering a similar approach, here is what I would tell you: start with the error handling, not the happy path. Write the failure cases first. That is where the protocol either holds or breaks, and you won't know which until you've tested both.
