The Onomastics of Software
Never before in the history of humanity is a literally unimaginably complicated technology present in every household that everyone uses and relies on. The study of computer science encompasses not only many fields of mathematics (including geometry, boolean logic, and differential equations) but also electrical engineering, semiconductor engineering, digital logic, linguistics, psychology, and even novel fields, such as network theory.
Software engineering, in particular, is plagued by a particular type of complexity, namely that of increasing number of functionalities. To manage this, engineers have created innumerable tools to help us deal with source code. Little did they know, choosing the tools themselves is non-trivial, hence why naming these tools is important. It’s just a name, no? It’s far more important to have the tools working as intended instead.
Still, there are stacks on stacks of abstracted-away complexity so that people rarely try to understand a technology from the ground up, which makes most of us tinkerers of source code instead of engineers or growers. By understanding the names of the tools we use to tinker/build/grow, we are taking a particularly unique path in trying to understand how different technologies are interwoven with one another and how their names play a part in recognizing these tools.
But are names meaningful in the first place, beyond their associated meanings to objects or people? Arguably, no: Anyone named “Michal” does not necessarily have anything to do with the archangel Michael, from where the name originates from. Someone named “Victor” doesn’t necessarily have anything to do with “winning”/being victorious. But at the same time, when we name our children, we put in much thought as to which name we pick to make sure they don’t have certain associations.
What about software names? Let’s take a few examples: Maya, Kubernetes, Overleaf… these names make no sense at first glance, and for their sake, thankfully, so that they may carve out their own meaning. But if we dig into the names a little further, just like if we were to do it with personal names, we find something fascinating:
- “Maya” has been named after the Hindi word for “illusion”, relating to the nature of the software: special effects creation.
- “Overleaf”, makes the metaphor that while we may have written texts on “leaves” back in the past and paper today, “Overleaf” suggests it is somehow “above” the old format, a better version thereof. In particular, multiple people can work on the same document at the same time, which, for LaTeX code, was unprecedented.
- “Kubernetes” is a word that comes from the ancient Greek word for “Captain”/” helmsman”, where it is pulling forward the metaphor of shipping containers from some software container technology. The “Kubernetes” can also be understood to be the captain of the container ship.
From these, it seems that software names are not, in fact, meaningless but hold modica of relations to other ideas. This is exactly what I have decided to study for my master’s thesis: To arrive at the initial meanings of software names. It’s a very different approach to learning about software than the usual route of experimentation, programming, and compiler techniques. Instead, my research for the thesis turned more towards historical linguistics than computer science, a field I was initially very unfamiliar with, leaving me to push other, more scientific topics aside.
I don’t regret it though. The onomastics of software is a field that has largely been overlooked (most likely because the study of names is already a niche subject itself), which means that my study is a first of its kind, as far as I know. With computer science focusing on science, math, and even human-computer interaction, linguistics only plays a passing role. One of the few “computer language” publications is the “Hacker’s Dictionary” (also known as “The Jargon File”), which summarized hacker lingo of the 70s, 80s, and 90s, a good starting point in studying computerese. Despite this, it makes little to no mention of software names.
The reason for this is rather simple: back then, software was “simple”, in the sense that the number of underlying technologies that programs used were fairly small, which allowed programmers to program close to the registers of the CPU. Software was also not freely available, nor was sharing software a widespread concept.
This is most definitely, notoriously even, not the case today. Looking at any one of my Chrome tabs, they all use JavaScript to one extent or another, which means they likely use some JS framework, like React, Svelte, Angular, or others. These technologies work well on their own, but for a website to be useful in some way, they usually need to store data in some database: MongoDB, PostGreSQL, SQLite, Cassandra, etc. These are tied to the backend via a server, such as Django, node.js, or .NET, which in turn use packages/libraries to support them. Each of these subcomponents of software also have names.
Add to this the absolutely ridiculous number of different softwares that exist just to get the desired software to work; we thus get thousands of individual software. Given this aspect of modern technology, the task to “understand software names” does not seem as far-off a concept as before.
For the sake of interest, let’s skip over the methodology and data collection and jump right to my conclusions: A primary discovery of my research is that most software names are standalone names that refer to what the software does (unsurprising, really). For example, the node.js package “http-server” is exactly what it sounds like. This, however, isn’t always the case: We’ve seen that Kubernetes and Maya make metaphoric references to other languages, but there are also names whose meaning can only be extracted by a thorough etymological analysis.
The classic example of such an analysis is the programming language C++. It is said that C++ is simply C with classes. Programmatically, the “++” is the unary operator that adds 1 to a number, hence why “C++” is the “next version” of the C language. OK. But why did the creators choose to name their language “C” in the first place? Good question! “C” has been picked to identify the next version of another language called “B”, on which it was based. Following this logic, we infer that B is based on A…
…but this is not the case. There is no programming language called “A”. B has been named after BCPL, Basic CPL, to show that it is related to this even older language. BCPL, in turn, is derived from CPL, Common Programming Language, which is the last etymon to explicate the name “C++”.
Other examples we might want to mention are Python (not based on the snake, but on Monty Python), JavaScript (meant as a frontend language to Java, before becoming detached from it) and Perl (an intentional misspelling of “Pearl”, to “signify the language’s beauty”), which all have unique origins.
What other etymologies might we find in the realm of software names? An interesting question, one unanswered, until now.
Get Michał Burgunder’s stories in your inbox
Join Medium for free to get updates from this writer.
Names, in general, follow any rules they want to, but overall, can be categorized into one (or at most two) different groups:
- Attribution: Uses the name of a person
- Legal Entity: Uses the name of a product or organization (e.g., Microsoft Word, GNU/LINUX)
- Theme: Follows a given naming theme (e.g., snakes: Python, Cobra, Anaconda)
- Artifact: Refers to a concrete thing that has value in society (e.g. Ruby, Dog)
- Descriptor: Uses words within the name that describe its function (e.g., astropy, Python for astronomy)
- Version: Denotes a Version number (C, but also Modula-3, or PL/B, PL/C, etc.)
- Reference: Uses the name of another software in its name (rails_magick, referencing ruby on rails)
- Implicit: Uses a unique naming scheme, usually not apparent to a user (the programming language FORTH is partly a play-on-words to mean “To go forth”, however, the public version was the fourth version of the software, and the filenames could only hold five characters)
- None: The name is literally meaningless (the programming language “Julia” has been picked because the creator thought it was a nice name. That’s all)
Because people heavily consider what to name their software, many names tend to follow more than one naming scheme. If we restrict our understanding of what naming schemes they follow by creating a “hierarchy of meaningfulness”, we can effectively assign a first-level etymology to every name.
What I mean by a hierarchy of meaningfulness is clearly ambiguous, but then again, any such classification would be. A category (see above) that has more semantic value is ranked higher, while those with less are ranked lower. Hence, those names that are meaningless, such as “Julia”, are at the bottom, while software names, such as Descartes (based on the French polymath), are ranked at the top.
Such classifications can be done on all programming language names and software in general. Some categories are not as present in software names as in programming languages (most names in the Anaconda ecosystem are Descriptors), but it gives us the largest possible pool of categories that we can assign to software names. This way, reconstructing how people named software leads to a holistic overview of software names.
But this is only the beginning of the onomastics of software. How “long” are etymological chains that construct a name? How many other names are included in the creation process of a name? C++ has a depth of 4 (C, B, BCPL, CPL), but are there names with larger depth values?
It turns out, yes! One such example is the language J++, whose name originates from Java (hence the J), ++ (from C++), which means that the (maximum) depth of J++ is 5, one longer than C++. When looking at the “volume” of a node (named “opacity” & “influence” in my work), we find that most names do not depend on many names or “jargon” in order to explain it. But some names are so obscure they require sustained attention.
The Python Package “_ipyw_jlab_nb_ext_conf” makes no sense at first glance. But taking it apart, morpheme by morpheme, we arrive at an explication of the name: When we expand the acronyms used, we get something along the lines of “interactive Python widget”, jupyter lab, numba, extension, configuration”… which still doesn’t make much sense. But knowing that “interactive Python” allows for instant feedback, that jupyter lab is a data science tool, and that numba is a backend service for numpy (which in turn is a package that manages numerical data structures in Python), we can, to an extent, understand what the software package does.
These types of analyses can be done on virtually all names of software. Of course, those names that are not Descriptors will not have such a clear explanation, but instead, might have thematic relations, as seen with the containers and pods of Docker and Kubernetes. In these instances, containerization software might use the metaphor of a “container” on containerships, such as Digital Ocean Kubernetes Service does: Containerization seems to be related to the concept of ocean trade routes (note that Docker’s logo also includes a whale, indigenous in the ocean).
Beyond these things, there are plenty of other things one can record about software names. One thing that I got interested in was seeing how many animals are included in software as mascots, names or as logos. How much software is named after an animal, anyhow? Quite a few, in fact: I have counted at least 35 software names that include animals in their names. Even more surprising is that every software uses a different animal, often in different taxonomic families, and as far as I can tell, only the house cat has been used more than once (Scratch & IceCat). Even though software is entirely non-biological, it still uses zoology to identify itself.
Clearly, one cannot analyze all software in existence. This battle would be lost before it even started (sourceforge has over 100’000 different softwares for any one operating system). We can, however, get a small (tiny) glimpse of the onomastics of software by choosing small datasets that might be of interest and, from it, infer the onomastic landscape of information technology.
Notes
You check can out the full data set here: https://docs.google.com/spreadsheets/u/1/d/1h_RDU8NZPRNrLs1YORYF9m4SB2vk-hXwp4goTW8GlEM/edit#gid=1177884809
