ASCII : A Love Letter






What Does Programming Feel Like?

Most people don't imagine much when they picture the world of programming. It's one thing to imagine a programmer friend enjoying a take-away and some television in the evening, but imagining what he or she does all day at work is somehow (for most people) still an unknown. It's clear what a programmer does in a physical sense (presses keys on a keyboard, clicks the mouse, etc.), but it isn't clear what it is like to actually be a programmer - what does programming feel like?

If this is something you want to understand, perhaps a good place to start is with the main tool used by programmers: programming languages. Using a programming language is like writing down the specific tasks you want the computer to perform at a very precise level (for example adding two numbers). Very roughly, programming languages are half-way between natural languages (such as English) and mathematics. Like natural languages they have structure and a vocabulary. And like mathematics they are very concise and specific, and use many weird and unusual words and symbols for which the meanings have to be learned. But once you know a programming language, the process of actually commanding the computer is surprisingly simple. You don't need to learn how to use any complex software: all you do is write your program in a text file and open it with another program. That program reads what you have written and performs the tasks encoded by it.


This makes things a bit more clear until you realize there is no single programming language - there are thousands, and programmers typically learn dozens of programming languages over their careers. The time it takes to learn a new programming language can vary greatly. If the programmer already knows any similar languages it could take a weekend. If the language is particularly weird and complex it might take years. And while the most popular programming languages are often taught at university, some programming languages are so obscure that they are only known by a handful of people on the planet. The internet has archived hundreds of ancient programming languages - their users long since moved on to bigger and better things, retired, or in some cases, simply died. If you start learning one of these languages today, you may well be the world number one expert by tomorrow.

The richness of this spectrum is one of the many things that makes programming fascinating. It isn't uncommon for programmers to learn new languages in their spare time for fun - and many have dedicated their lives to studying existing languages, and even to developing their own! Programming language theory is one of the most interesting parts of programming - and half a century since their invention, they remain the most flexible, powerful instrument in the toolbox of a programmer.

For all these reasons, just being a programmer isn't enough to define your experience, and what programming languages you speak is considered a significant question in the programming community. It's like asking what country a person is from - it gives a quick insight into their background, many of their thoughts, their opinions and their experiences. And, just like natural languages, programming languages influence the people who speak them - they introduce an implicit culture and a world-view, because it's programming languages that give programmers the vocabulary to describe problems they encounter in the world and, more importantly, the potential solutions.


So people tend to identify with certain languages more than others, which leads to an amplification effect. People flock to the language that most accurately suits them, homogenizing the culture, and reducing the diversity of the group. This further alienates people with slightly differing opinions. Borders are drawn, nations grow, and flags are raised.

These factions have been known to engage in "religious wars" - endless debates across the chat rooms and bulletin boards of the internet - echoing the same arguments and insults about languages and the programmers who use them into the void for all eternity. Reading them is a bizarre experience - half theoretical debate between particle physicists, half childhood argument over which is better, Ferrari or Mercedes. Some people take programming languages very seriously.

So when programmers want to communicate code with each other, choosing a common programming language can be difficult. When the code doesn't actually need to be run by a computer, often the choice is a language called "pseudocode" - a kind of Esperanto of the programming world, an abstract and flexible amalgamation of the most common elements of programming languages, packaged up in a sensible clear syntax to try and ensure there is minimum confusion.

Often, this, combined with a bit of mathematics, is enough to get the point across, but not always. Just how Esperanto is undeniably a euro-centric global language, pseudocode would be classed by programmers as an "imperative" (a style of programming) global language. There are plenty of communities who won't speak it. Similarly, it doesn't matter to a monolingual Chinese speaker if you speak Esperanto or French: they're not going to understand, and (perhaps more to the point) half of the information would be lost in translation anyway.

Part of the reason for the explosion of programming languages is explained simply by the frenzied rate of technological development that has swept the modern world. With the progress that has been made in so many fields it is easy to forget that programming, in its current form (a tool that is likely to dominate the future of humanity for many hundreds of years to come), all but didn't exist 50 years ago.


This explosion is what tech journalism typically covers. We hear a lot about new machines, new businesses, and new personalities, but we hear very little about the quiet cultural revolution that has been happening alongside the development of programming and computer science driven by the common experience which all programmers share - a muffled eruption taking place in dark bedrooms, in basements and offices. An eruption of geeks, outcasts, gays, socialists, hippies and anarchists, nerds and losers. Much of it has been faceless - echoing only in its own spaces, propagating to the outside world slowly via the internet. On the outside it looks bizarre and frantic and impossible to decipher, but on the inside you will find a number of things that have come to unite programmers. A sense of generosity and selflessness, a love of clever and playful things, a wish to remain faceless or anonymous, an absence of financial motivation and an overarching longing to be accepted. These remain the same regardless of the programming language being spoken.

And there is a good reason to sit up and take notice of this culture which has rumbled away quietly. Just like its technological counterpart it will play a large role in the future of humanity. It will become mainstream: programming will be taught in high school like English and mathematics, and the experiences of the programmer today will be the model for the experience of many millions of children to come.

Because programming has no logo this has all crept up on people. While some logos have been adopted by a few fringe groups: Tux the penguin, Gnu the Gnu, the Glider from The Game of Life, these represent smaller groups of programmers - speakers of certain languages and users of certain tools.

If we are interested in showing people how it feels to be a programmer, then this logo is what we should be looking for. We need to know what aesthetic symbols represent us as programmers - the objects that demonstrate our common experiences and bring us together regardless of faction and creed. These are the stones left over from the destruction of the tower of babel and each one, to me, is a precious artifact.

In this archaeological dig, the most significant stone that has been turned over so far are the set of symbols called "ASCII".

ASCII stands for "American Standard Code for Information Interchange", and roughly it is an agreed set of symbols, and the encoding for those symbols, that allows programmers and computers to communicate textual data. It was developed in the 1960s but has stuck around a long time since then.

There are 95 printable characters specified by ASCII (including the space character). 52 of these characters are the alphabetic characters, 10 are the numerals, and the other 33 are various miscellaneous symbols that largely hold their place thanks to a number of different historical circumstances.


Most lay-people may have never used, or even seen, many of the symbols in ASCII before. Characters such as 'pipe' |, 'tilde' ~, 'hash' #, and 'at' @ might all seem very odd things to include (although the latter two are more familiar to people these days thanks to Twitter). Equally many lay-people may be just as surprised at some of the omissions. People in the UK might be wondering where the 'pound sign' £ is (which sits above the 3 key on our keyboards)?

Japanese people also lack their own symbol to denote money. They solved this problem by having Japanese software draw the ASCII 'backslash' character \ as a yen symbol ¥ on screen - a decision that has caused endless interesting side effects, such as file paths on Japanese versions of Windows gaining a very expensive look (e.g. C:¥Windows¥Microsoft.NET¥Framework¥').


Programmers, unlike lay people, will know all these ASCII symbols well. This is because programming languages almost exclusively use ASCII symbols to represent code. Programmers typically type hundreds or even thousands of these symbols every day and no single symbol goes without use, but programmers are just as confused about the choice and provenance of the symbols. For example, much programming involves mathematics. Why then are there symbols for 'plus' +, 'minus' - (a borrowed hyphen) and 'equals' =, but not for multiplication or division? Programmers are forced to use 'asterisk' * to represent multiplication and 'forward slash' / to represent division.

The simple reason for the selection of symbols (which anyone who is a little older than me will have already guessed) is that almost all of the ASCII symbols derive directly from the symbols that were on standard American typewriters of the day - a time when programming still didn't really exist and most typewriters were used only for accountancy and admin.

This at least explains the 'at' symbol @ and the 'hash' symbol #. 'At' @ was originally intended as a shorthand to signify the price various goods were bought at (e.g. '4 tables @ $128'), and 'hash' # was used to represent identifying numbers (e.g. 'shipment #512').

The typewriter also explains another group of symbols that were originally meant to be typed over the top of previous symbols. On a typewriter the backspace key doesn't erase the previous character but literally moves the paper backward by the width of a space. This explains the accent characters ^, ~ and ` that were placed over other letters. It also explains why the division symbol is missing - previously an approximation was achieved by typing the hyphen character - and then the colon : character on top (for multiplication the x character was used). This also explains 'underscore' _. Bold characters could be printed on a typewriter by directly printing the same character two or three times on top of itself but italics were impossible. 'Underscore' was introduced so underlined text could be used as an alternative. On a computer you can't type one symbol on top of another so these things no longer make any sense. The accent symbols can no longer be written on top of other characters and instead take up the space of a full character on their own. Programmers use underscore more like a hyphen - to conjoin words when leaving a blank space would change the meaning of the program (e.g. slots_num).


It is interesting that as many of these characters have completely lost their original context and meaning they have gained an entirely new purpose in writing code. For example 'pipe' | is used to chain a series of commands, and 'tilde' ~ means to flip the binary representation of a number. Even more interesting is that programmers have been forced to combine symbols in creative ways, for example putting 'hyphen' - next to 'greater than' > to make 'arrow' ->, putting 'hash' # next to 'exclamation mark' ! to make a symbol called 'she-bang' #!, or putting two 'greater than's > next to 'equals' = to make an obscure symbol called 'monadic bind' >>=. These are just a few examples from thousands.

The ASCII symbols are a set of symbols that all programmers have close experience with. And they are more than just a set of symbols - they are the words with which all programmers have learned to speak and the symbols that every programmer has dealt with working long into the night. No single programming language, but rather ASCII represents the common language of programming culture - the silent, subtle communication that has built so much and allowed thousands of programmers from around the world to slowly, independently, construct a new tower of babel.

My most recent project has been a collaboration with a close poet friend of mine on a book of code poetry: a collection of poems written in the source code of several different programming languages.

Just like programming culture, the collection is intended to be fun and clever. Each poem is also a valid program, producing an output that visually represents the content of the poem. The code is hidden in the poem, the poem is hidden in the code, and the whole thing can be read by both human and machine.

Also, like programming culture in general, this collection is intended to be generous, providing an fun, personal, and colorful exploration of the medium. Some people might enjoy delving deeper into this collection but you don’t have to be an expert to appreciate it. The book can just as easily be read as a series of nonsense poems - a surface-level abstract presentation of immediate feelings and thoughts.


So although programmers will be the people who I hope understand it the best and appreciate this collection the most, it is also a collection for those who are not programmers but who want to know what the future will be like. Because the common experience of programmers will soon be the common experience of everyone, and if you are interested in a preview of the aesthetic world which at the moment is still secret, but very soon, will be all unavoidable, this collection provides it.

I've often teased my girlfriend by saying I was going to get a tattoo of the 95 printable ASCII characters. Her reaction is always the same - an expression which says both "please don't", and "you massive nerd" at the same time. So unofficially, I like to think of this collection as my missing love letter to ASCII - a thank you note to those 95 weird little symbols that have ended up representing my life and the life of many others like me.