In today’s world, service men and women have a variety of roles to choose from when enlisting in the armed services. From aircraft maintenance to specializing in biomedical equipment, the modern soldier does more now than ever to accomplish mission success.
As cyber systems become more relevant, it is imperative that we train our service members accordingly. It is here I pose a question:
How do we effectively train our service members to develop and maintain software applications?
If we are able to train people that start with nearly zero knowledge of avionics to maintain electronics on tactical warfighters, how do we train people that start with nearly zero knowledge of coding to maintain software codebases for military applications?
There are many advantages to having service members learn software development and integrate within software development teams. For one, by collecting insights from service members and getting access to service members that actually use the software day-to-day, development can be focused around the most critical workflows that users will exercise in the field. If they are developing products for themselves, service members become invested in the quality of the software that they have to use every day. If mission needs change, there is less lag time in developing new products or putting out new features. This list goes on. Making this happen is no trivial task and comes with a significant cost of ramp up time and effort.
In my day to day, I work with United States Space Force software developers and product managers to develop and manage software applications.
In my journey I have found two tools to be particularly useful and effective when ramping up brand new developers: Paired Programming and Test Driven Development. These two practices are the cornerstone of Extreme Programming (XP) – a software development methodology developed by Kent Beck and championed by VMWare (formerly Pivotal).
Across the software industry, paired programming has been touted as a tool to improve quality, produce fewer bugs in production, and prevent single points of failure. Although these are a few of the numerous benefits of paired programming, one of the greatest benefits I have observed from pairing is the ability to share knowledge continuously and in real time.
By pairing with service members and immersing the new developers straight into the code – they learn software development not just by watching, but by doing.
Pairing also has the added benefit of working in reverse by bringing and disseminating a wealth of new domain expertise from the newly integrated service members.
The second tool I found particularly useful is Test-Driven Development (TDD). TDD is a technique for developing software that starts with writing tests that guide developers to the implementation of functional code.
It can be described in three steps:
- Start by writing a test for a small “unit” of functionality we want to add.
- Then create the code for the test to pass.
- Finally refactor both the new and old code to make it well structured.
By implementing software in this way, new developers can easily digest small units of functionality and understand the step-by-step process on how more complex components are built out. TDD also makes building software simple and introduces a fast feedback cycle that not only allows for better software with less errors, but also enables developers to learn from what they just coded.
Ramping up new developers and product managers can be hard. With these two tools, you can cut the time it takes to train new developers, and in turn, transform organizations.