Language is a difficult topic to discuss directly because it is such an essential part of our experience of reality. Words are the most primitive tool at our disposal to construct meaning. So ingrained is language in our comprehension of reality that even internally we explain reality through self-dialog, a stream of consciousness championed by an internal narrator explaning reality back to ourselves.
Even though we continuously reap the benefits of language's evolution as a method of effectively exchanging meaning between biological information processing machines, we are still hesitant to accept its utility when constructing systems of codified meaning for computers, choosing instead to manufacture new formal systems for organizing information, often with a near religious devotion to the prescribed axioms and standards of its creators.
"I lay claim in this novel", I heard him say, "to the essential qualities of all games: symmetry, arbitrary rules, tedium."~Borges' Ficciones
Creating a formal system is no easy task. All decisions made by an individual, even those with the best intentions towards impartiality, add some aspects of themselves as an imprint on their work.
Programming languages are a relatively nascent technology. The first imperative programming languages appeared in the mid 1950s, making the field of programming roughly sixty years old. Unsuprisingly, many people have relatives who are older than our field's entire history.
A programming language has the special requirement of requiring a compiler, a special set of code that interprets and encodes the meaning of the language in lower-level machine code. This requirement creates conditions where many languages are mostly authored by the single individuals, most likely engineers, who are responsible for developing their machine implementation.
Even now what we know to be the entire breadth of programming syntax and concepts comes from small teams at academic institutions and corporations, who at their worst, have particular interests or business objectives attached to the success of their languages, and at their best, are biased to an expressed ideological agenda. As many have noted, often what seem later to be the better language lose out.
| Linguistic Concept | Programming Concept |
|---|---|
| Words | Instances |
| Ideals (Forms) | Classes |
| Modifiers | Properties, Settings |
| Verbs | Methods |
| Tense | State |
Many programmers not only solve complex abstract problems routinely, but spend their free time thinking about the meta-tendencies of solving problems. How can i write this quicker next time? How can I avoid repetitive tasks? How can I abstract this out to be re-used? There is a fundamental tendency for computer programmers who are innate problem solvers to look for intellectual solutions to problems, to see all problems as solvable using the same techniques which problems are solved inside the curly quotes of programming.
These predispositions are extremely useful traits for system design, but can lead to biases as a field to intellectualize issues, to search for a unifying set of axioms which should guide all future programming. For one, simple solutions may not always feel as gratifying as complex ones. The current version of programmatic truth is usually seen as the Truth, the current best practices, as the only practice for a good developer, whether next year they might be disavowed or forgotten for the new big thing. Though this mania drives innovation forward, many of these new big things become the old standards soon enough, but they nonetheless encourage a shared, irrational obsession with novel rational appeal.
Classifying, creating rules, drawing boundaries are all essential parts of being a programmer. Much of what makes up the functionality of programming may not have common accepted language, so individuals are forced to construct language more than many other fields. Many of those 'named things' in programming, the guts of a program, will only be read by several people in their lifetime, sometimes even one, so the conventions can be determined by particular, singular conditions.
Programmers who are limited by the predetermined syntax of interpreted languages (the parts of code defined for machines), feel bound to use similar machine-like rules for naming the parts of code defined just for other human editors.
Many coding languages are still chosen under the belief that the most important features of a language is computational efficiency. For a long time this was true. Systems were just too slow, and compilers too inefficient to deal with code that didn't make the needs of computers paramount. This may have been painfully obvious in a period of time when most personal computers didn't have hard drives.
But this period is drawing to a close. Not only are processors' transistors now only a few nanometers wide, but compiler improvements by browser-makers increase performance by double digits regularly.
The age when images, text, and video cannot be constructed, manipulated, and animated on a page at sixty frames-per-second are drawing to a close, yet many programming languages do not appear to acknowledge the need to adjust for this shift in focus.
Even if pure functionalism and the talk of humans as being peculiar types of machines makes you want to run and hide in a far-away room, the argument that natural languages are much better equipped than prescribed languages to create meaning doesn't necessarily have to be tackled philosophically.
Many features of natural languages are convergent, arising simultenously in different parts of the world with no contact. Natural languages even evolved under similar constraints as programming languages.
Bandwidth plays a critical role in natural languages, being even more restrictive than computer systems. Speaking requiring us to physically contort internal valves in our larynx to modulate the frequency of waves of air pressure at a rate of only 150 or so words per minute—and that's not say anything of the fascinating complexity in our capacity to observe those same modulations.
Natural languages are also designed to limit not just the length of encoding to a collection of sounds, but also to optimally limit the conceptual scope of ideas into classes, nouns, and account for varying implementations of an idea effectively through qualifiers.
Often times the connotations (tech-speak: "implementation") may vary from person to person of an idea. Love may connote ideas of romantic love, or in others felings of agape, or specific memories with a quality you only can understand, yet four letters and one sylabble are enough to contain the concept.
A single idea may also vary from instance to instance. A normal horse might have four legs, but if you encountered a three-legged horse you would find no difficulty considering it a horse. In fact, you may never encounter a three-legged horse, and still might store space for it conceptually based purely on your imagination of the possibility. Or the classic Wittgenstein example of "What is a game?". Natural language can accomodate for these variations in implementation, tempered by a "development history" that started longer ago than we even had the means to record it
Individual interface elements are the nouns (tech-speak: "classes") which provide a context ("scope") to limit the broadness ("encapsulate") of modifiers ("properties") and behaviors ("methods").
Natural languages are used today for describing interface design, although they aren't usually considered in the actual process of coding interfaces. Words like popup, dropdown, and modal didn't exist twenty years ago, yet now most people who visit websites understand these as essential elements of a design. They know what to expect from their behavior, how to use them, and can distinguish them in a design.
The resolute success industry-wide of "flattening" design: removing gradients and reducing the use of shadows, recanting of skeumorphic design, defining relationships through negative spacing instead of borders, etc. shows there is a directionality to interface languages. We can convey meaning with less affordances than ever, not primarily because web developers' understanding of design has evolved, but because users' understanding of design has evolved from years of usage.
It's important to explain, that this argument only applies directly to exchange languages like HTML and not all programming languages. The meat and potatoes of most programming can be much more complex. Moods, sentiments, feelings — the internal "processing languages" of meaning in organic systems can difficult to comprehend, and utterly unaccountable by language.
This translation is only % complete!
We need your help to make Semantic available to people who speak your language.
Our translation tools are easy to use and allow you to translate text without having to leave the site. If you are interested in joining our translation team please e-mail me for access to our translation hub.
