The Next Fantastic Software Project Code Name
Tags: watercooler, career, beginners, motivation
Published: 2021-07-27 10:27:22

Boring software and hardware are named for what they are.

Buttoned up and formalized, application and library names like `The-App-Brand-Name,` `What-I-Do-Library,` and  `Named-Service` are ordinary. Projects like `Go-to-Market,` `This-Product-Release,` `Sprint-Number,` or `Minimum-Viable-Product` are manufactured in an assembly line. And the hardware of `Domain-N-Series-Y,` `Give-Me-The-Last-Digits-On-That-VM` fades from memory faster than a trending [Hacker News](https://news.ycombinator.com/) post.

I first experienced naming things *differently* while developing software in a team. The websites and apps we built did not have adored handles. But the blades on a server rack *did* have names. They were the *pets* hosting these projects. 

Each server had a name from one of the Greek/Roman gods. `Pollux,` `Apollo,` `Castor,` all had a memorable name and function. `Castor` was the webserver, `Pollux` was the file server. The list went on down each metallic bay. And when we added a server, [we plotted how](https://datatracker.ietf.org/doc/html/rfc1178) to name it well. `Hermes,` one of our later additions, was where we dropped questionable payloads; it was a mess of libations.

These names and their power are *pervasive*, sticky in my mind forever. But naming servers this way is archaic today and challenges the typically discussed [pets/cattle metaphor](http://cloudscaling.com/blog/cloud-computing/the-history-of-pets-vs-cattle/). If I squint hard enough, the names could be construed as fungible parts.

I still remember those machines, the projects they hosted, and the people that showed me how. I cannot remember any of the server clusters I managed since. And I haven't seen enough of this clever thinking. We need more of that geek passion while we horizontally scale to infinity.

## Some Examples I've Experienced

Every label that I've encountered is a function of its culture and the people around it. It's a mix of generation, nationality, motivation, shared experiences, and values. When mixing these attributes and a giddy sense of a clever play on the words, a project handle explodes to a *code name* many can get behind.

The result is a memory hook. And those who participate are now part of the *in-group*. Calling something by a code name makes the experience inclusive and gives the group control and ownership. The name is a badge of complete honor, commitment, and *undying passion* of it, this love, for this thing to succeed.

In my experience, code names rise from various contexts. And in each context, there are an infinite number of ways to arrange, enumerate, and organize in an endearing, proud, or unbelievable way. They are named after science, animals, products, history, mythology, toys, animation/anime, famous adored leaders, music, and many others. The possibilities go on and on.

Let me share some examples I've experienced, which will be very different from your experience.

### Nostalgia

When I was involved in kid media-focused software development, handles were based on cartoon nostalgia. App names were concentrated in supporting [NickToon](https://www.imdb.com/title/tt6611256/) characters `Tommy,` `Blue,` `Otto,` and others associated with their app function.

In that project, we created a mono repo where the streaming apps and supporting libraries were located. We called it the `Aggrocrag.` Named after the Kids show, [Nickelodeon Guts](https://en.wikipedia.org/wiki/Nickelodeon_Guts), the final challenge was contestants completed, racing up a polystyrene mountain. We got a few chuckles out of it. And then there was the common shared library that was way too all-knowing. We called it `Olmec,` named after a [game co-host](https://nickelodeon.fandom.com/wiki/Olmec).

I once developed a private suite of tools individually labeled as [M.A.S.K.](https://en.wikipedia.org/wiki/M.A.S.K._(TV_series)) characters. Examples included `Trekker` and `T-Bob.` This was essentially a self-help developer experience toolchain, no feeling more incredible than having the complete collection of those toys and at the same time having insight into developing better.

### Relevant Releases

Some software projects had passion names. With the projects focused on Android app development, we went through a list of Asimov and sidekick robots. `Daleks,` `Atlas,` `Yaris,` and others all had a special meaning and contained changes related to the robot and its characteristics. Obviously, `Daleks` was crafted to [*exterminate* things](https://youtu.be/RhEUBgu9j5Y), removing unused features unabated. The developers would label each in turn on release, and it was shared ownership that blossomed.

More recently, the team I managed named releases after Pokemon characters. I remember the end of years releases of `Haunter` and `Pidgeot,` aptly named after the American holidays. The name concept was new to these engineers. Perhaps the experience will be the motivation to name their next project.

### Organization and Platforms

In one shop, two major engineering teams came together. We called the shared developing platform the `Hadron Collider.` An amalgam of different technologies in JavaScript, from render engine to UI, attempting to stream a video experience on as many devices as possible.

While the engineering organization was serious about its outcome, our team named existing *native* apps after non-scientific instruments. Apps were named after amusement park rides, like the `Gravitron,` each app's fate mixed into the organizational fun over time.

### Timeline and Phases

At some part of my career, I joined a startup. We named our WebRTC communication app deliveries after satellites launched up to space like `Telstar,` `Voyager,` and `Hubble.` Their supporting SDKs were named after [Back to the Future](https://www.imdb.com/title/tt0088763/) paraphernalia. `Hoverboard,` `Delorean,` these abstractions powered these satellites.

Even the build server code releases were named in a co-tenant fashion after famous astronauts and cosmonauts like `Tereshkova` and `Armstrong.` These pipelines supported our continuous releases.

The MVP (a second iteration of the failed `Voyager`) called `Voyager 2` was released. It did okay, but somewhat its cruises in the ether, semi-distant, never quite achieving its mission.

### Tools and Utilities

Tools and utilities typically have brutally crafty names. Since most of the software is focused on outcomes, the clever succinctness can be off the charts.

I've built small tools that have been discarded — naming them out of love and utility. There was `Scrapi,` a small, scrappy API scraper, `Amazement,` an iOS game where you trace out of a maze, and `Bif-Tannen,` a [base index file](https://developer.roku.com/docs/developer-program/media-playback/trick-mode/bif-file-creation.md) QA and extractor tool for movie thumbnails.

And for those that authored their libraries creatively. `Importanize,` an [import and organize tool for Python](https://github.com/miki725/importanize) was more recently memorable and helpful.

## Naming Things Make Memorable Story Telling

I've seen many series, magnitudes, and creative labels over the years. I've only shared where I actively contributed.

Code names have a rich history. The practice came from ages ago in government and the military. And further in the dawn when inventions were developed and labeled in Edison times at Menlo Park. Engineers are creative. They are inventive, [even with project names](https://artsy.github.io/blog/2019/05/10/why-projects-need-codenames/).

I find code names are *sentimental* hooks in the playful nature of the software craft. It's about the culture of the engineers, something that we enjoy doing.

These aliases are a remedied prescription to the unambiguous. Engineers long for a territory to raise their flock of beautiful software and hardware. Damned the boredom of names like `This-is-an-App,` or `Some-Service.` Instead, let's have the `Anti-Gravity-Device` and `Newtons-Gravitational-Laws.`

The power of these labels is about telling stories, *galvanizing people* where the hook is the code name we all discuss in the digital hallways. [Software engineers need to believe in their projects](https://iism.org/article/you-need-software-developers-to-believe-in-your-project-45). But without the naming practice, there isn't much infatuation or fun. It's not memorable. There isn't much play. *Another sprint ends in the bin, semantically tagged.*

Let's create the next fantastic code name. I plan to.

---

*My mobile devices are named after moons in the Solar System. My favorite memorable phone was `Phobos,` my Samsung Note 7. Some weeks after I bought the device, it was banned from airplane flights due to the explosive nature of the internal battery. I picked up its replacement and called it `Demios,` a smaller version of its bigger cousin, the LG V20. Because of these names, I remembered them long after they were gone.*

*I write this post on my machines — `Tabulator` and `Hippocamp.` Thanks to the podcast Reconcilable Differences for the inspiration to get this concept across the finish line. Their episode, [#159: The Narrow Priesthood](https://www.relay.fm/rd/159), inspired me. And the book [Project Hail Mary](https://www.andyweirauthor.com/books/project-hail-mary) by Andy Weir reminded me that references to project names are culturally crucial in all endeavors.*