One of the lesser–known skills computer science students pick up in college is the ability to create pseudo-languages.
I’m not talking about coding languages, but systems of interpretation, where certain words and phrases map to particular meanings. These pseudo-languages aren’t spoken, but reveal themselves in almost every part of the field, such as in network administration and programming, creating implicit lexicons that streamline problem-solving methodologies.
Stranger yet is the fact that these languages are formulated in a way that’s natural and almost commonplace to us all. In fact, we have all, at some point, created these sorts of systems, perhaps even without our knowledge.
Language 2.0
Suppose you are tasked with vacuuming all the rooms of a thousand-room building. If each room in the building is identical to the next – same doors, lights and furniture orientation – how would you keep track of the rooms you’ve vacuumed so far?
It wouldn’t be efficient to keep a running tally of the number of rooms you’ve finished, as miscounting means having to check again whether each room has been vacuumed – a tedious process, to say the least. Instead, it would be better to exploit the fact that each room has a light switch. Assuming the lights are on in each of the rooms come time for you to vacuum, you can indicate to yourself that you’ve finished cleaning a room by turning off its lights. As you progress through each of the thousand rooms, you need only see which rooms are dark to keep track of what you’ve vacuumed so far.
This solution is an example of the aforementioned pseudo-language. By indicating the condition of a room based on whether its lights are on or off, you’ve encoded a binary scheme to keep track of each room’s state. Essentially, you’ve created a tacit lexicon and adhere to it to solve the problem at hand.
Interestingly, this idea of using a system of interpretation seems quite intuitive – which explains why it’s so prevalent in our everyday lives. For example, we cross out items on a list to indicate whether or not they’re complete and we use different colored tabs in binders to represent different class’ paperwork. Each of these systems utilizes a different self-made lexicon to address the specific problem at hand, be that organization or task delegation. As computer science is obsessed with problem-solving, it’s not hard to see how the field is littered with these kinds of pseudo-language systems.
In fact, every computer’s basic machinery is built around such a pseudo-language construct. Computer processors can only understand binary code, but not all data can be easily represented in that format, thus posing an interesting challenge. For example, in order to represent negative numbers in binary, you would have to use an extra binary digit to indicate a number’s sign, where a ‘1’ indicates that the number is negative and a ‘0’ otherwise – the basis for a system known as two’s complement. Likewise, many such systems of interpretations have been created to represent various types of data, like pixel colors or letters on a screen.
Hence, it’s clear that these systems of interpretation, given their methodical nature, go hand-in-hand with algorithmic problem-solving, and thus computer science. It’s not just computers themselves, either. Everyone from programmers to chip manufacturers utilize their own unique systems of interpretation to aid in the problem-solving process. While this makes for an interesting class of solutions, it also adds something that’s perhaps less apparent: flavor.
Artful conventions
The ubiquity of pseudo-languages in computer science brings up a peculiar notion of expressiveness in the field. While developing systems of interpretation is mostly a mechanical process, some of those underlying methodologies can be manifestations of the creators’ own stylistic preferences.
For example, when tasked with writing a software application to keep track of the open seats in a movie theater, there are many systems of interpretation that can be employed. For instance, each seat can be codified into coordinates on a Cartesian graph and used alongside different colored dots to represent different seat states. Alternatively, each seat could be assigned a number, where each number would be placed in a list and paired with a one or zero to indicate whether or not the seat is empty – such a system is known as a bit-vector.
Of course, the nature of the problem being solved places constraints on the applicable pseudo-languages, but even after these limitations are taken into consideration, there are still multiple systems one can go about implementing.
For instance, if the movie theater program needs tablet display capabilities and requires the ability to update quickly to allow ushers to direct moviegoers to open seats, both the graph system and bit-vector would be appropriate. Both can update seat states quickly – one uses coordinates and colors, while the other uses seat numbers and a binary ‘switch’. Additionally, both can be implemented into a graphical system to display on a tablet.
Certainly, one system of interpretation might seem easier to implement than the other, but that ultimately comes down to stylistic tendencies of each computer scientist – I personally find it more appealing to use a bit-vector, but someone who is more graphically oriented may lean toward the graph-based system.
If we think about these various preferences, we can see that in some ways, the pseudo-languages that computer scientists employ are reflections of their personal tastes. What’s more, the presence of different pseudo-languages means there is a sense of freedom to computer science – a fresh breath of vitality that diversifies a seemingly mechanical field.
In other words, these design decisions are like forms of expression, much like how different painters use different brush techniques to carve their unique styles into their pieces. And the very fact that we can make that kind of comparison means that computer science, in some ways, resembles art – a case for arguing why it’s not only accessible, but also beautiful.