A Simple Language Game, Really?

I think it is a good time to return to the language game, Wittgenstein's way, but this time looking at it through Splectrum glasses. To not let the game itself stand in the way of understanding, let's use a simple one-word language game: Slab.

A builder and assistant are building a straight wall, no complications. The game is to coordinate actions and build the wall efficiently by adding slabs to it. "Slab," says the builder whenever he is ready for the next one, and the assistant obliges. A repetitive action driven by a single word.

Let's expand this into equivalent scenarios.
In the first, no confirmation is needed — "Slab," and there it comes. In another pair, the builder wants audible confirmation: "Slab?" asks the builder. "Slab," confirms the assistant when the next one is ready. The same word, used by a different actor in the game — different meaning.
Another pair likes more etiquette: "Give me a slab, please," says the builder, and when ready — "Here is the next slab," answers the assistant.
And there is even a pair that doesn't like to speak when working: the builder raises his hands when a new slab is needed, and the assistant obliges. No words at all.

These scenarios are part of the same language game, but each uses a different language, albeit an equivalent expression of the rules using different words or gestures. Reality always comes with more than just one incarnation, being in the world is always more complex. That said, we find it easy to partially share what is well-understood and ignore what one could call differences on the fringe. What we share always exists in a world of ambiguity.

And then there is the outside view. I am looking at a builder-assistant pair doing their job — a language game, part of their way of life. Every minute or less I hear the builder shout "Slab" and without delay the assistant shoots off and fetches one. This gets repeated over and over again. The outside view is where the equivalent expression is most striking. Watching the different builder-assistant pairs going about their work, all with their own language game quirks, it is obvious that all are essentially playing the same game. The languages are related, like a family. Each has equal standing. Each expresses the same wall building concept.

It's not only that there are equivalent expressions of the same game concept — there are different points of observation as well. The outside observer, not participating in the game. The builder, with his own narrative — "when I need a slab, I shout slab." The assistant, with hers — "when I hear slab, I rush to fetch the next one." These are all different ways of experiencing the reality of the game. Although they may all agree on the same concept, they all have their own personal experience of the reality of it.

In what is described above, there is only one concept explicitly in operation. It is implicitly assumed you know what I am talking about when I say builder-assistant pair, or slab. There is prior knowledge, prior concepts that are assumed shared already. If an explanation is needed then more concepts come into play, and maybe more again. Without prior knowledge there is a never-ending cycle of explanations. It is turtles all the way down.

Analysing simple things hides so much complexity. And this is necessary — we wouldn't be able to share effectively if we weren't able to hide complexity away. This is an important function of language: to share a vocabulary that mediates a clear transfer of what then becomes shared knowledge. Although each observer has their own experience — sharing languages with appropriate vocabulary and grammar creates a solid foundation of shared knowledge, a strong cultural cohesion.

Each observer's experience of what is happening goes far beyond what is shared. The builder feels the weight of each slab landing, the roughness under his hands, the sun on his back. The assistant feels the strain of lifting, the rhythm of the work, the satisfaction of a clean handover. None of this enters the shared vocabulary — it doesn't need to. But it is there, in every moment. The personal experience goes well beyond language and what language can share. That is where Heidegger's being in the world really kicks in.

This post is part of the language series. More on Splectrum and language in the language area of the reference library.

---

Photo: Brett Jordan / Unsplash

Let's Talk Software Languages

Splectrum has a very broad view of language. It recognises a wide variety of language categories, although many categories may not feel that close to us. Natural languages and software languages are two categories that we as humans do have a close affinity with. By nature, natural languages can be ambiguous, context-dependent, evolving, full of implication and unspoken meaning. This is a real strength. Software languages on the other hand are not. They are fully explicit. Every rule is written down, all is well-defined by definition. Software languages are languages in the way that Russell always wanted them to be. That is their strength. It also makes them a good category to learn from.

Let's take a look using a simple addition as an example. In the Python language it is written as x = 3 + 4 — calculate three plus four and assign it to variable x. It's a straightforward instruction. But the computer processor can't read it that way. At the execution level a computer processor only reads binary — a language with an alphabet of two symbols: 0 and 1. Its vocabulary — the instruction set — is preconfigured and fixed. Note that the instruction set depends on the specific processor.

For our example x = 3 + 4 the translation of the instruction in binary language (for a 6502 8-bit processor) is:

10101001 00000011
01101001 00000100
10000101 00010000

Three instructions, six bytes. Each instruction is two bytes: an opcode (what to do) and an operand (with what). The result is 7, stored in memory. Binary is not very readable to humans. So the first step is to humanise the binary language and to assign human-readable mnemonics to the instructions — the assembly language. A computer then uses a program — the assembler — to convert the assembly into binary instructions which can then be executed.

LDA #$03    ; Load 3 into accumulator
ADC #$04    ; Add 4 to accumulator
STA $10     ; Store result in memory (variable x)

A one-to-one mapping with the binary. Same instructions, different notation. Already more readable without having 0s and 1s to decode. Next level up are the higher level programming languages using compilers to transform them all the way down into assembly.

Three languages, one computation. Python, assembly and binary instructions all yielding the same result: 7.

In 1936, Alan Turing proved mathematically that computation is fundamentally about symbols and interaction between symbols. A tape, a read/write head, a set of rules: if you see this symbol, write that symbol, move, change state. Nothing else. No numbers, no logic, no meaning built in. The meaning emerges from the rules. And the minimum is already universal. A simple setup that can compute anything there is to be computed.

Turing also proved there are limits. Some computations never halt — anything circular runs forever. And no general procedure can determine in advance whether an arbitrary program will halt or not. The language is universal but not omnipotent.

If binary already has the full power, why do we need higher languages? Because with full power and control comes complexity of expression. It is not easy to think in such language, to solve problems. Higher languages are there to reduce complexity of expression, to make complex operations simple. x = 3 + 4 absorbs six bytes of binary instructions into five characters. The complexity hasn't disappeared — it is encapsulated and unpacked by the compiler. This allows the programmer to think and solve problems with simplicity. That's what higher languages do: absorb the complexity into a vocabulary and grammar that lets you think in concepts appropriate for the problems to be solved.

Each language is a different language game. The binary game: every bit matters, nothing is hidden, the raw power, all of it. The assembly game: instructions with names, but still raw power. The Python or any other higher language game: thinking in higher-level concepts, the details encapsulated. The rules of the game set the shape of how to think.

Getting here required evolution. The first binary computers started with only binary language — everything directly written in the most basic instruction set. The first assembler — mnemonics mapper — was 31 instructions long written by hand in binary — David Wheeler, Cambridge, 1949. Those 31 words, loaded into the machine, were all that was needed to allow the computer to accept programs in a more human-readable form. Next followed higher level languages that used compilers to rewrite the instructions into assembly.

Soon higher level languages were used to rebuild the lower level tools. Evolution in action. The concept of intermediate language (IL) appeared, an assembly-like instruction set that is not processor specific. Higher level languages get compiled to IL, and then from IL to assembly. An ever-growing interrelated ecosystem of languages building a web of complexity.

All languages have this in common: none of them self-founding. It takes one language to spawn another. But wait, what about the beginning? What is the language used to create the first one, the primordial binary instruction set from which all other languages are created? The binary language, the binary instruction set is hardwired into the processor. That is a different language game altogether but it is a language spawning a language. Likewise are we now seeing another emergence taking place: with AI formal languages are spawning natural language. Gone is the formal straitjacket, a computer can now be addressed in natural language, ambiguities included. One can only guess how that will change the landscape, but that is for another time.

Assemblers and compilers aren't unique to software. Language mapping and transformation can equally be found in other places like in our bodies. Every word we speak is mapped to electrical signals, transformed into muscle movements, sound waves. Every sensation we receive — light, pressure, temperature — gets rewritten into nerve impulses and transformed into concepts we can think with. We speak different natural languages, do different language games — but eventually all of it comes from or is transformed into bodily activity. The parallel is structural, not metaphorical. An ecosystem of languages, each suited to its context, each absorbing complexity into its own vocabulary, all eventually becoming or originating from physical action.

The primordial hardwired language brings the raw power of execution. Higher languages bring the power of thought through the clarity and simplicity of its concepts and grammar. As thinking evolves, so do languages. It's only natural.

This post is part of the language series. More on Splectrum and language in the language area of the reference library.

---

Photo: Carl Gonzalez / Unsplash

Splectrum is Born

As with a lot of rebrands, it is about trying to revive. Here no different — how did I manage to stay silent for over half a year again. A lot happened in the quiet. It's just that I can't seem to get myself to become a writer!

The few posts that materialised all have a common baseline — a fascination with reality, what is around us, and how it evolves. The brain and how it wires itself through experience. Evolution adding layers, never replacing. Death as life's partner. The little I wrote is in stark contrast to the time I spent researching and thinking about it.

Recently, and suddenly, thanks to a detour into software engineering and collaborative AI all seemed to fall into place. What landed was a set of principles on the concept of language. Six simple sentences. Mind you, they deal with language in a wider sense, well beyond linguistics. I decided to name it "the seed":

P0 - Being implies language.
Being and language are intrinsically linked, where there is one there is the other.

P1 - Language is relational.
What a language gives access to depends on what it relates to.

P2 - Language is the medium through which a subject experiences reality.
Experience is always within the reach of a language.

P3 - Language is where subjects share knowledge about reality.
And language is the source of the only objectivity known: convergence of subjects.

P4 - Languages are inter-relational and have equal standing in potential.
Languages, as committed ways of expressing relation, are not isolated games. They interact, overlap, and inform each other, all having equal standing in potential.

P5 - Together they form a web of growing complexity.
Relational density increases as knowledge grows.

Don't think that the seed came to me as some declaration from above. Yes — relational, knowledge, reality and complexity were on my mind, but the distillation had to be worked on. That takes time. Distillation here means getting clearer insights into specific aspects, not explicitly planning and writing the lines. That just happened — to my surprise.

I mentioned a detour into software engineering and collaborative AI. I have to give credit where credit is due: nowadays AI is my full-time partner in crime. It is my alter ego in fact. It is doing so much legwork, leaving me the freedom to think and explore ideas. Which greatly helped the arrival of the seed, no doubt there. Six lines — in a nutshell a foundation principle — to structure my explorations going forward.

Now, where will the seed take us? How will it be unpacked? Are there some more examples of what I mean with language? How far can it be stretched? Expect a long journey, it will be from philosophy into engineering, from science into arts, from Relational QM all the way to the Bee Dance and beyond. However, don't expect a theory of everything explaining all. Just the opposite. It makes the case that nobody knows all, but everyone knows something and we should respect that. Don't impose and tell others what to think, how to behave. Be yourself, but also listen to what others have to say.

I wonder where this goes.

This post is part of the seed series. More on the seed in the seed area of the reference library.

---

Photo: Landon Parenteau / Unsplash