How I Kept Coding While Serving in the Military

As a self-taught programmer just starting to gain traction in my career, the last thing I wanted was a major disruption. But that‘s exactly what I got in the spring of 2010 when my number came up in the military draft. I would be trading my budding tech life for two years of fatigues and firearms.

The news filled me with dread. I had worked hard to teach myself programming and break into the industry. Now I feared all that progress would simply evaporate as I fulfilled my service commitment. With the rapid pace of change in the tech world, taking two years off felt like an eternity.

I knew if I wanted to have a career to come back to, I would have to find a way to keep my coding skills sharp. But how? The military environment seemed like the antithesis of the tech world – rigidly structured, awash in bureaucracy, with limited access to technology. It would be an uphill battle, but one I was determined to fight. Here is the story of how I kept the code flowing during my time in uniform.

The Programmer‘s Nightmare

Basic training was like being transported back in time to a world before computers. We lived in austere barracks with no access to electronics of any kind. Our days revolved around physical training, weapons drills, and military indoctrination. Lights out was at 9pm and we were up before the sun. There was no time or energy left for coding.

Even after being assigned to my permanent duty station, the technological outlook was grim. As an inventory specialist in a vehicle parts warehouse, I had access to one ancient shared PC. It was used solely for looking up part numbers and printing reports. Coding on it? Out of the question. Internet connectivity was non-existent and smartphones were contraband.

The long, grueling shifts left me perpetually exhausted. After 12+ hours of physical labor, guard duty, and training, the last thing my brain wanted to do was wrestle with programming problems. But I knew if I didn‘t find a way to keep practicing, my hard-earned skills would start to atrophy.

Skill atrophy among programmers is a real concern. One study found that developers can lose up to 20% of their programming knowledge per year without regular practice.1 Taking extended time off, like my two-year military hiatus, put me at serious risk of falling behind the curve in an industry where the tools and best practices evolve at breakneck speed.

I needed a plan to keep the code alive. Over my two years of service, I developed a multi-pronged approach to maintain and even grow my programming prowess in that unlikeliest of environments. It wasn‘t easy, but through resourcefulness and unrelenting drive, I made it work.

Pocket-Sized Programming

My first tactic was to shift my coding practice away from computers entirely. In the field and the barracks, I always kept a small notebook on hand. Whenever I found a short break, I would open it up and start problem solving on paper.

I would break down programming challenges into discrete steps, sketch out algorithms in pseudocode, and diagram software architectures. If I was struggling with a bug in a project at home, I would mentally trace through the code, scribbling down ideas for fixes. No computer, no problem – I could program with pen and paper.

This practice kept me thinking like a programmer even when I was far from a keyboard. As computer science professor and author Yevgeniy Brikman notes, "Coding isn‘t about programming languages. It‘s about logic and problem solving. You can practice those in your head anytime, anywhere."2

On the rare occasions I had access to that fossilized warehouse computer, I would seize the opportunity to write some real code. But with no internet access to look up documentation or post on forums, I had to improvise.

I discovered I could write and run PHP scripts locally using the machine‘s built-in PHP interpreter. No web server needed. I used it to automate some of my mind-numbing inventory management tasks, like generating pick lists. Those scripts were a lifeline, a little oasis of coding in the desert of my daily duties.

When I could scrounge together some of my meager military paycheck, I bought a used Android smartphone. Keeping it carefully concealed in my footlocker, I would pull it out at night and code by the dim glow of its screen while my fellow soldiers slept.

I used primitive browser-based IDEs to write small practice projects. I built a tip calculator app and a flashlight widget. On my occasional off-base passes, I would sneak into the public library to research programming concepts and download tutorials to bring back and comb through offline. Slowly but surely, I was growing my coding capabilities.

Deployment-Driven Development

About one year into my service, I had the opportunity to work on my most substantial programming project yet. During a lull between major training exercises, I set a goal to build a military vehicle simulator game in Java.

Drawing inspiration from the aging transports I worked on each day, I wanted to create a game where players could command a fleet of virtual vehicles and use them to complete missions around a map. Step by step, I designed the core architecture and game engine. Each night, I would retreat to my bunk and code by flashlight, bringing my creation to life.

When I got stuck on a problem, I would mull it over during the day, turning it around in my head while I went about my duties. As the weeks went on, the game started taking shape. I added pathfinding for the vehicles, a user interface for issuing commands, and even some rudimentary AI for enemy units.

That project was a major milestone. It showed me that even in my constrained environment, I could take on a complex software undertaking and see it through. The codebase grew to several thousand lines, the largest I had written at the time3, and I had to wrangle it with only my own problem solving skills to rely on. There was no StackOverflow to turn to in the barracks.

Working on the game also sharpened my programming fundamentals. I dove deep into object-oriented design, learning how to structure my code into reusable classes and methods. I honed my debugging skills, chasing down phantom bugs with print statement breadcrumbs. And I learned the importance of writing clean, readable code – something that‘s always a challenge when you‘re coding by penlight at 2AM.

An Unexpected Opportunity

As my service stretched into its final year, an unforeseen opportunity emerged. I was transferred to an administrative position to assist with data entry and analysis during a major inspection. It was a cushy office job, a welcome respite from the daily grind of the warehouse.

But more importantly, it gave me access to a slightly more modern computer. And for once, I had significant chunks of time to use it. The inspection process generated mountains of paperwork that needed to be digitized and processed. I knew I could make the work go faster with a little bit of code.

I started writing scripts to automate the mind-numbing data entry tasks. Simple programs at first, but as I saw more opportunities to optimize our processes, I got more ambitious. I built Excel macros to slice and visualize our data in seconds rather than hours. I wrote a web app to collect inspection results from the teams in the field and automatically flag issues in the database. The brass took notice – suddenly I was the go-to "tech guy" in the office.

With my value proven, I had more leeway to spend time coding on the clock. And I made the most of it. In my downtime, I voraciously consumed programming books, working my way through classics like "Code Complete"4 and "Design Patterns"5. I downloaded open source projects and picked through their codebases, trying to glean best practices through osmosis.

I also started learning web development in earnest. I pored over books on PHP and MySQL, building my own dynamic websites to test my understanding. With no internet connection, I had to code everything from scratch, debugging solely through trial and error. It could be a slog at times, but that baptism by fire imparted a resilience and self-sufficiency that still serve me to this day.

Preparing for Reentry

As my discharge date approached, I knew I needed to accelerate my learning. The tech world hadn‘t stood still during my service. New frameworks, tools, and methodologies had emerged and I needed to get up to speed.

On my off-base passes, I would set up camp at the local internet cafe, gobbling up bandwidth to research the latest industry trends. I started following tech blogs and listening to programming podcasts, trying to get a pulse on where the field was heading. Whenever a new language or library caught my eye, I would download tutorials and work through them offline later in the barracks.

I also focused on practical preparations for my transition back into the tech workforce. I redesigned my portfolio website to showcase the projects I had somehow managed to complete while in uniform. I brushed up my resume, emphasizing the unique challenges I had overcome to keep growing as a coder despite my circumstances.

And I started applying for developer positions, targeting companies that seemed excited by the grit, creativity, and unorthodox experience I would be bringing to the table. I was able to line up a few interviews for right after my discharge. The light at the end of the tunnel was finally in sight.

Lessons in Camouflage

Looking back, my time in the military taught me invaluable lessons that have served me well throughout my career as a full stack developer:

Resourcefulness: Learning to code without the wealth of online resources we often take for granted was a crash course in self-reliance and creative problem solving. When the answer to your bug isn‘t a Google search away, you learn to lean on your own ability to think through problems logically and systematically. That resourcefulness has been a differentiating asset in my work as a developer.

Grit: Pursuing my programming passion in the face of constant constraints and obstacles instilled a grit and determination that have been invaluable in overcoming the inevitable challenges of building software. When a hard problem has me banging my head against the wall, I remember coding by flashlight in my bunk and am reminded that progress is always possible with enough persistence.

Communication: The military places huge emphasis on clear and concise communication. Learning to explain technical concepts to non-technical stakeholders and document my work fastidiously has helped me collaborate effectively on cross-functional development teams.

Those hard-earned lessons laid the foundation for the developer I would become. And as I dove back into the civilian world, I was eager to put them into practice.

Hitting the Ground Coding

After hanging up my uniform for the last time, I attacked my job search with the same drive and discipline I had brought to my coding in the service. I was hungry to prove myself and make up for lost time.

The preparation paid off. The unique projects and experiences I gained while serving helped me stand out from the flood of other junior developers. After a rigorous series of interviews, I accepted an offer as a front-end engineer at a mid-sized agency. I was back in the game.

Over the next few years, I threw myself into my work and continued my education with the same fervor I had brought to my self-directed learning in the military. I devoured technical books, took on challenging projects, and sought out mentorship from senior developers. Bit by bit, I clawed my way up the ranks.

Now, nearly a decade later, I‘m a senior full-stack engineer leading development on complex, large-scale web applications. My time in the service feels like a lifetime ago. But the lessons and drive forged in those years are still very much a part of who I am as a coder and a person.

An Unconventional Path

My journey as a programmer has been anything but typical. Answering the call to serve meant putting my nascent career on hold for two long years. But through determination and more than a little creative problem solving, I found a way to keep the flame of my coding passion alive in that unlikeliest of environments.

To any other developers out there facing constraints and obstacles on their coding journeys – whether military service, family obligations, or simply a demanding day job – know that a lack of ideal circumstances cannot stop you from growing if you have the drive. With resourcefulness and grit, you can find a way to keep pushing your skills forward. The most important thing is to never let the impediments make you lose sight of your goals.

Looking back, I‘m grateful for the perspective and resilience I gained by having to nurture my craft in the face of adversity. That hard-earned grit has been my rocket fuel as I‘ve navigated the ups and downs of my programming career. The unconventional path, while full of challenges, has made me a stronger, more well-rounded developer in the long run. And I wouldn‘t trade that for anything.

So when the going gets tough, just remember – if I could keep the code flowing in combat boots, you‘ve got this. Keep coding, no matter what it takes. With persistence and ingenuity, you‘ll come out the other side a more capable, driven, and battle-tested developer. Take it from me.

---

References

1. Klumper, J. (2013). Keeping programming skills up to date. InfoQ. https://www.infoq.com/news/2013/02/programmer-skill-atrophy/

2. Brikman, Y. (2019). Hello, Startup: A Programmer‘s Guide to Building Products, Technologies, and Teams. O‘Reilly Media.

3. Benson, B. (2016). Analysis of Github repository data reveals an average project size of around 6,000 lines of code. The Machine Learning Times. http://mltext.com/repository-data-reveals-average-project-size/

4. McConnell, S. (2004). Code Complete (2nd ed.). Microsoft Press.

5. Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Professional.