Essay on language, history and system design
Lo! to the vault
Of paved heaven,
With sorrow fraught,
My notes are driven:
They strike the ear of Night,
Make weak the eyes of Day;
They make mad the roaring winds,
And with the tempests play,
— Mad Song, William Blake
I wouldn’t a tiny bit be surprised if it turned out that in fact, nothing else but magic, as-in aesthetically pleasing phenomenon, is the true villain, who ends up taking up all the available space, whilst wrecking everything up in the process. Yet, it’s me, the one who’s desperately in need of it. Hell, magic is what keeps people doing one of the most industrious activities of all, algebra. And I do not say that lightly. By Heaven, if not some wicked sense of satisfaction mathematicians recover from algebra, is what keeps them doing it, God knows what does. There absolutely must be something about language that accounts for this sort of excitement of imagination; language resides precisely where lays the distinction between the real and the imagined. If the sky was synthesized, you’d probably know, right?
This kind of uncertainty bothers me, but it’s by no means the chief subject of this essay.
First, there was mess
You know what a great black box looks like from the inside? You don’t. With its supposed true greatness, in very limited case would you be tempted to, only with the greatest of difficulty would you be bothered to—look, and without looking you never would find out. When the epistemic limitation, to how well we attain knowledge, approaches the utility limit of such knowledge, only then are we tempted to see beneath the smoke, and only as a result of lucky and timely gaze, order per se can be established. Any scientists aware of the law of entropy will tell you that perfect order cannot ever be achieved. We know that from nature, science, religion; pretty much everything we claim to know, hints onto the fact that any system is destined to venture into chaos, sooner or later, one way or another. But perfect order, the limit case, is it bound to have meaning, just as non-limit case does? From the black box perspective, the perfect order is actually possible and can be achieved provided we’re able to see through the box so clearly, to be fully aware of how it works, whilst having no reason to aquire this knowledge. I like this definition, because it seems to have an interesting implication: we can think of order as-if determined by the language of the box, which I think will prove to be a much more useful framework for system design, rather than the naive scientific explanation, concerned with the law of entropy.
It’s no big secret people suck as dealing with large arrays of information, or large number of people, for that matter. Perhaps we are also bad at precise estimates and solving enigmas. Thus we employ computers, and in some cases, networks of computer networks, to do the job. And how do you control the computers? Well, thanks God for that we have the Architects: different kind of programmers, engineers, developers, and all the others. It really is of no interest how they identify themselves professionally, what’s important is that they all belong to one community; chosen ones, these having holy insight into the machinery! I honestly believe it’s a shame software engineers currently hold monopoly of system design! Think about it, computer programmers is only a small subset of all people, that actively engage in system design today. And the box is too hard, they say. It’s an abstraction, black abstraction, and how they made it pretty scary too, “computers are complicated, you see.” I refuse to accept this. I especially do at times, when these systems are so very much needed in so many different areas of our life. It’s in everyone’s best interest to take system design of computer networks out of greedy and possessive hands of software engineers, attempting a little revolution-like sleight of hand trick, that would allow anyone concerned with things like language, logic, and problem-solving—to easily learn about, or maybe even directly affect how things around them are run. And yes, I do quite literally accuse programmers of burgeousee. Obviously, this cannot be achieved by further specialising the field. And please make notice that I’m by no means making a scandalous argument. In fact, I’m only but reciting what software engineers were saying about specialised hardware back in the day when software wasn’t remotely as commonplace. And it wasn’t so long ago either. But ways have changed. It’s one thing when the box does 2+2, it’s the other when it affects what information people get exposed to, on the large scale. Do I want to keep control of this digital reality in the hands of the corporate few, who think maybe too high of their work, sure well aware of their power, yet failing to admit their specialized, biased, and often quite limiting outlook? We can’t make everyone programmers, but we can make computers accessible to everyone. This cannot be achieved by further programming; it must be clear how the boxes work, and it’s only clear when it can be said clearly. Naturally, when tasked to tell sense from nonsense, I shall turn to philosophy.
There is absolutely no doubt about how the current state of affairs in system design is both very messy and at the same time, very promising. The kind of systems I’m particularly interested in discussing are open participation computer networks, as this framework still remains the only scalable, and in the long-term perspective, the only viable approach to data interchange, that we can reasonably expect people to reason about. What I find most interesting in regard to this particular brand of networking, is the extent to which it employs virtualisation. Kubernetes, for example, is created to make us think of computer applications as-if built on a completely different foundation than they really are. And I can only warn of the ambiguity that is steaming from this; not a good thing. To illustrate the idea, I came up with this analogy: For to enable what’s possible now, the technological steeple of the Cloud had been built all the way up from the very foundation: commodity computer hardware, whatever they use in the data centres, GNU/Linux networking stack, et cetera. Now, sitting up there with it being very high up, at certain height you no longer see land beneath the thick skies of cloud and smoke from all the machinery residing somewhere in the numerous pillars. You don’t have to imagine the land either, all the while you could just walk down and see it for yourself. Neither should you be bothered with machinery, in any case unless it is the thing you really wish to bother yourself with.
Honestly, I do not wish so. And as disillusioned in postmodern jargon as I am, there simply doesn’t appear to be a more effective way of thinking about machinery other than such method, that would let go, or shall I say, deconstruct the very act of its programming, when sought to be applied to the language of the machinery itself. To me, that’s ultimately what AI, in its canonical and purest form, is all about. When thinking of artificial intelligence, we don’t quite mean all the fancy statistical models, robots, all sorts of amusing neural networks, or anything like that. In the films, recently more so Nietzschean ones, beyond any reasonable amount of doubt favoured in the circles of the Architects, aforementioned system designers, the ones maintaining computer systems, the only primary manifestation of AI is such of a language interface. Ironically, it’s likely a female robot that’s maybe too unsettlingly comforting for a chit-chat. God save the ones who would bury their shield on battleground in the faintest attempt to prove that AI in any sense more about programming, than it is about language!
Poetry aside, it’s the notion of mind-picture we form about the land, by looking at it from the above, that-is all concealed beneath the smoke, I should wish to be preoccupied with in this essay, and to that I will devote my closest attention.
Then there was order
Talking of order, if I’m going to attempt deconstructing programming, which is very much a
written act, I might as well bring out some formal notation of my own, hopefully sensible at
that. Pay attention, the notation shouldn’t be treated like a programming language of some kind,
but rather as language language. It attempts to describe dialects, possibilities of
target discourses in the form of straightforward propositional grammar. A few of the things to
notice: (1) it inherits Wittgensteinian distinction between saying and showing, thereby
introducing the corresponding signs,
:= meaning to say, and
:: to show a definition of
some sign; (2) If the line starts with
//, it’s a comment that is meant to elaborate upon the
formal ways of notation. Hopefully, I will be able to convince even the most sceptical of
readers in utility of the proposed analysis. But let’s take care of the infinities first, and
then proceed to interesting stuff real quick.
// 1. Void manifests itself. void. // 2. Iota is an intangible particle, a form distinguished from void. // // Whilst void is the infinitely large, which is the totality of all // possible propositions, iota is the infinitely small. And that is // a single definition, correspondingly. // // Iota is a proposition, void is lack thereof. // iota := not void.
Void here symbolises the infinitely big, and iota stands for the infinitely small. You should think of void as of lack of distinction, the background. Iota, on the other hand, introduces the notion of distinction. All further propositions will be derived from it. One of the possible distinctions to be made is that of truthfulness and the two booleans, true and false.
// 3. Boolean is a iota of truthfulness. // boolean := iota. // 4. True and false are the two boolean possibilities. // true, false := boolean.
So far I’ve only used
:= as to talk about symbols, but apart from symbol we must specify how
they are ought to be used, e.g. define propositions in which these symbols occur. In my
notation, propositional form can be described with an arbitrary set of signs, such as
-, numbers or words. Please note that not all signs of the proposition must have
meaning, for it to be sensible. This would be considered nonsense in programming, but makes
perfect sense in the realm of language.
I will now briefly describe basic logical operations on the two introduced boolean symbols.
// 5. Basic logical propositions therein described. // not p := p := boolean. -> p ? true -> false. false -> true. p and q := p, q := boolean. -> p ? true -> q. false -> false. p or q := p, q := boolean. -> p ? true -> true. false -> q.
As you can see here, apart of new uses of the existing punctuation, there’s clearly a new
way of things: implication
->, which is essentially modus ponens of the grammar.
When the proposition to the left of it is the case, then what’s to the right of it is
considered the case as well. When to its left there’s nothing, then it implies the proposition
that is being described. For example, with
not p, the indentation show two possibilities
p being either true or false, and the proposition was implied to be either false or true,
correspondingly. Obviously, the space (indentation) is also meaningful, insofar it allows to
trace the bounds of each clause distinctly.
Other operations, like logical addition, can then be easily derived from the existing propositions:
p xor q := p, q := boolean. -> (p or q) and not (p and q).
Simple if-then-else clause can be described very easily in under a handful of lines, yet
again we would need to introduce the last remaining piece of punctuation, that is
to indicate the expansion of the text, where
t is the text, a non-empty series of
propositions. This allows to treat an arbitrary text as a proposition itself, and make
sense of it in appropriate contexts.
// 6. Text is a non-empty series of propositions. // text := iota... // 8. If-then-else with subtext clauses. // // This first makes use of the (expand) text... syntax, // in order to read the text in full if the condition // is the case. // // if <condition is true>, then // <clause> // else // <alternative clause> // if condition, then clause := condition := boolean. clause := text. condition -> clause... -> condition. condition else alternative clause := condition := boolean. alternative clause := text. not condition -> alternative clause...
Other propositions can be described in the same fashion. The linguistic form can mimic natural language with all of its redundancy, if needed. For example, suppose you’d like to formalise, like I do here in my essay, something like the procedural code, or any other discourse-form, in which it matters who is talking, what can or cannot be said, and the rules of how this interaction can be determined logically. In fact, just in the meantime of me typing this text, all kinds of procedures are being successfully carried out, with me having nothing to do with them whatsoever, yet it would be hard for me to believe there’s much of accidental in how they are run.
Sceptical reader will at once turn themselves to question: what use the bloody notation, introduced by God knows whom, in God knows what essay, could possibly have to do with real problems, existing and flourishing, unfortunately, in real domains? These domains are far, far more complicated than conceptualisms of the sort introduced earlier. And I could only but advise such reader to further continue reading the essay. To this point, I admittedly used the notation to say so little. I will further use it to show things that cannot be said, and these are as important as the once that can. The concept, I borrowed from Wittgenstein’s. But being no academic scholar of Wittgenstein, I cannot claim my method to be corresponding to such of Professor’s. As a matter of fact, I can already point out a single (of many) contradictions; to his belief Wittgenstein, that-is which can’t be shown was of prime importance, I do not agree. This view would certainly be sensible, if we were to put language in the centre of all things, but it’s the Man, not language—a mere tool, that sits above all else. Therefore the deed of saying, the very urge, appeal to language—is primary, but only in the same sense the Man is primary, which it really is not. In other words, unless you’re not above all concerned with the use of language for its own sake, I don’t know, for the beauty of it, but the very necessity of it, you’ll find “the rules” of the game just as important, as the game itself.
Quid pro quo
Quid pro quo is a Latin phrase used in English to mean an exchange of goods or services, in which one transfer is contingent upon the other; “a favour for a favour”, “give and take”, “tit for tat”, “one hand washes the other.” Why bother with it, then? Quid pro quo corresponds to the simplest formal discourse with two or more defined subjects, therefore it’s the most primitive form of discourse, that presupposes external world. I could say, “Here is a tree.” At the same time you could replace me with anyone else and the sense of the proposition wouldn’t change, as long as a similar point was being made. In case of quid pro quo, there clearly is more than one concrete subject. Being the building block it is, you will find it as commonplace in technology, as anywhere else. For example, you engage in quid pro quo every time you trade your personal information for some tools or services online. The latest state-of-the-art voice-powered “home assistants” allow making of rather complex deals, to which it’s hard to say how exactly you engage in them, when it’s all done by voice. Forget ink and paper! Now, the question is how does this form of discourse generally map onto a computer system? If we were to use a computer as a black quid pro quo box, what would that box look like from the inside? I argue, it’s worth looking in, especially considering how the current state of the affairs with regards to people’s rights online and their implementation are short of greatness, that I would expect an invincible black box to exhibit.
The answer is: it’s unclear. No one really thinks of these transactions as meaningful, hence
no assessment of their sense are made explicitly, but only inderectly, by various obscure
means of judgement we are wired to perform. What is a whole number? Surely, if we’re going
to formalise some form of barter, the notion of quantity would arise immediately. Apples,
oranges, bananas. Naturally, we use whole numbers to indicate availability, or lack of—all
these goods. But on paper, we only yet can say nothing, make some distinction, as was done to
false quite successfully. But whole numbers? Oh my principia, oh my mathematica!
For those who don’t know, mathematics is quite devilish when it comes to detail, once
one is compelled to talk of what numbers are, it all gets funny very fast.
I, of course, will not bother with any of that. Instead, I will use the show symbol, denoted
::, to make sense by means of showing how the sign or proposition is meant to be used. When
describing discourse, it’s the only that matters, after all. (As long as you’re chiefly occupied
with language above else.) And you better bloody should be! Please, I appeal to you remembering
what the job really is. In this essay, I not only attempt to contribute to the great labout
I can see needs to be underaken to eventually liberate us from all the intricacies of how his
language really corresponds to Man, but to computer also—in the most real of reality,
that is the beatiful nature with nowadays, a dash of stacked machinery, surrounding it here
and up there.
In 1925, G.E. Moore famously came up with A Defence of Common Sense. In the essay, Professor claims that there is a set of
propositions that are sure to be certain, meaning we can be certain of them to be true.
He proves the existence of the external world by waving one hand, then waving the other—
mesmerizing the audience with the final revelation that something akin to the world
exists and in it you will find at least these two hands, of course. I think Moore’s idea is
much deeper than he and others originally thought, at the time. Maybe some didn’t, but being
a rather uneducated bore myself, I shouldn’t be aware. Yet I’m well aware that Wittgenstein
was. At any rate, the certainty is so easily reached, for the reason that the proposition
“my hands exist” does not really describe the world, as empirical propositions do.
Empirical propositions are either true or false, and that is determined by the exact state of
the affairs, as things stand in the world. But “my hands exist” is no such proposition, as
it’s contrary would not be either true or false, but sheer nonsense instead. Granted for any
sane person in the room. It’s a logical proposition, and to be dealt with accordingly.
Let’s presume the talking, ones who play they part in the play of discourse, to be sane.
Programmers are also quite sane. No one will argue that
2+2 = 4 or that you can’t really
devide by zero. This certainty doesn’t need to be said, rather it manifests itself and we’re
only able to show it. So let’s show some idea of a whole number, or rather how it can be
expressed, by providing some idea of a comprehensive list of all the propositional forms
that arise from the very acknowledgement of the fact the sign is meant to correspond:
// 10. Whole number, maximum absolute value is 9223372036854775807. // // |max| (either max, or -max) is the largest possible value // int can maintain until it overflows. // int :: int + int -> int. int - int -> int. int * int -> int. int / int -> int. int ^ int -> int. int > int -> bool. int < int -> bool. int >= int -> bool. int <= int -> bool. int mod int -> int. |int| -> int.
Of course, there’s quite a few other things you can do with integers: compare them,
for example, or apply modulo. And if I were to describe integers in their full, I decidedly
>=. Make notice not to mistake for grammar the nonsensical
parts of propositions, signs like
-. It must be clear that the punctuation of the
proposed notation is there to show what otherwise can’t be shown by the limitation, inherent
to the grammar itself. Thereby,
-> are part of the grammar, in themselves
punctuation, intended to indicate a notion of showing or following, correspondingly,
- are not punctuations, but the signs themselves. On their own they are nonsensical,
but when used in a proposition, they appear in the structure of proposition. This can be confusing to
those, who are used to treat them like operators, say in programming, where all operators are
considered part of the grammar.
I have no doubt that programmers are able to figure out atomic propositions, such as
2+2 = 4 correctly, and even for nonsensical propositions, such as
1÷0 = x there is
always a deterministic way of telling whether if a proposition itself makes sense, and if so,
it can be computed. But I’m no programmer now, I’m a merchant. And all I want to do is to
describe, by means of language and a little punctuation, what the deal is.
Money hasn’t been invented in my time yet, so it’s barter, but fair barter nonetheless.
For example, a good merchant that I am, will never trade a banana for no less than 2 apples,
neither will I ever give an orange away for no less than two whole bananas.
I could then compose a Merchant symbol, that would make a stock for each of the goods:
// This symbol is composed of others. Merchant :: Apples, Oranges, Bananas := int.
This could do for a fictional example, but won’t usually work for real. Most of the time, even goods of the same kind can be different in different ways, so keeping track of quantity only—won’t do. The notation weeps for a sequence of some sort, therefore I’m obliged to introduce a notion of a list: enumerated series of objects, denoted by a shared sign.
// 12. List is used to express a finite series of numbered elements. // item list :: (list) (index := int) // Get item by its index in the list. list[index] -> item. // True if item(s) is/are in the list. item... in list -> boolean. // True if item(s) is/are not in the list. item not in list -> boolean. // Total number of items in the list. list length -> int. // First occurrence of item. find item in list -> index. // Count occurrences of item. count item in list -> int. // Imperatives. add item to list! remove item from list! put item before list[index]! delete list[index]! swap i and j of list := i, j := int. list[i], list[j] = list[i], list[j]!
So a list behaves like your regular list. You can learn of its length, as well as retrieve its elements and manipulate their arrangement. And if I’m going to introduce lists, I might as well allow a symbol that would allow to correspond other symbols to one another, a dictionary. In a dictionary, to every unique A corresponds some B. Without much thought about it, I’ll just proceed to show what the dictionary is, or rather define its use:
// 16. Dictionary allows to go from keys to values. // from key to value :: (dictionary) (key, value := iota) dictionary[key] -> value. // True if key is in the mapping. keys in dictionary -> boolean. // True if key is not in the mapping. keys not in dictionary -> boolean. // Get the value by key. key dictionary -> value. dictionary of key -> value. // Imperatives. key dictionary = value! dictionary of key = value! delete dictionary[key]!
As you can see, the form of dictionary proposition is rather complex, thus in order to concisely formulate,
(dictionary) is introduced immediately and used later in the definition. All that being said,
we now have boolean logic, if-then-else, whole numbers, lists and dictionaries. This seems about
sufficient to describe the merchant affairs. This time, let’s have a dictionary to map from goods to
their value with respect to the other goods. Provided we possess a plenty of apples, and an
apple considered the cheapest good, I will use that as a base:
Commodity := iota. Hair dryer, Car, Cupboard := Commodity. Merchant :: beneficiary := actor. products := Commodity list. price := from Commodity to int. // Only propositions which end in ! can mutate state. Buy tit for some tat from Merchant! := tit, tat := Commodity some := int // but how does the merchant know their // customer is got enough of tat?
I introduced a Merchant now, and explicitly said (in parentheses) what its constituencies are.
Then I even attempted to define a simple
Buy tit for tat! proposition, but it turns
out there’s no good of a merchant if they can’t trade their stuff. So who is who? Define who.
One can say rubbish, and many routinely do. All the rubbish, if it’s rightly so, shouldn’t matter at all, simply in the same way logic ignores nonsense; a sane man would discard utterings of a madman as pointless, not worth of assessment. The only who matters, is the one who talks sense and others can agree upon it. Telling sense in its own way must be considered an act, and these who do so, subjects of discourse, shall be called actors.
In a classical Blockchain system, you can create as many actors as you wish, as long as your computer can reliably produce prime numbers randomly enough. Blockchain passport is a cryptographic key—clever mathematical enigma, but nothing more. Identity management is much harder than that. In fact, how do you tell real people from bots, manipulators from legitimate counterparties, and what if you would want to use the data as a definitive proof in the court of law? There’s more to an actor than a mathematical riddle. To me, it seems such notation that aims to formalise discourse, must acknowledge the key characteristic of its subject: the distinctness of its actors—these who do the speaking—at the same time, keeping identity management open to implementation. Forums, businesses, government agencies will all want to manage identities differently, and you shouldn’t worry about that too much, they will have their programmers to manage this.
// 14. Actor is a iota of the people. // actor := iota. // 15. This is the currently speaking actor. // this := actor.
As in the case of
boolean, a iota of truthfulness,
actor as well a iota in itself, admittedly
special in the way it’s treated with respect to the real-life environment, and the purpose of
it is to see clearly who’s said what. Unlike the boolean case, I won’t attempt to define
actor proposiitons, but as every other propositions, actor can be shown to be or not to
be equal to the other actor, allowing for proposition form
a = b or
a is b, where a and b
are actors, even though my notation doesn’t specifically distinguish between different actor
The snippet also introduces another standard sign,
this, which is always no-one else, but
the actor, the one who does speaking at the very moment. Now, not only are we able to
distinguish between speakers, we can always use
this to refer to the current speaker.
But even knowing all that, how would we know if the buyer is got enough goods for a
fair barter? Now let’s try to describe quid pro quo once again, but this time I will do
things a little differently and will make a use of actor maps. Merchants can only trade
with other merchants, of course.
Merchants := from actor to Merchant. Merchant has some of Commodity := some := int total := count Commodity in Merchant#products -> total >= n Merchant rate on something := something := Commodity -> Merchant#price of something Buy tit for some tat from Merchant! := tit, tat := Commodity some := int if this, Merchant#beneficiary not in Merchants, then panic! buyer := this of Merchants. if not (buyer has some of tat), then panic! enough := some * (Merchant rate on tat) / (Merchant rate on tit) if not (seller has enough of tit), then panic! // now, the barter can take place.
If at any point, any of the assertions above, and propositions stated as they are—they really are assertions, and being logical propositions, they are prone to be false, or simply false. When this is the case, the complete act of speech, in which the proposition is uttered, shall be considered compromised. Unless, of course, we strive to give up integrity, and with it the value of truth, as-in veritas, rightness—when it comes to determine what’s mess, and what’s order. In the computer system, we value consistency, availability, and partitioning, maybe—because data is important. And no, although I have a ready point, I’m not going to say more than a word about CAP theorem, and focus on system design instead. Currently, most computer systems are built into three fundamental parts: there’s the data layer, magic in the form of a computer program, where all the computation takes place, and the interface—systems often need to interact with the outside world. Many scholars in the field of computer science like to pretend they can ignore this, but it’s not really a problem: whereas you’re a passionate solipsist, or an absolute realist, there’s absolutely no difference in how you would assess the affairs. And what use of rightness, when unconcealedness, that which we call transparency, not only cannot yet be achieved, but the very urge to cleanse the doors of yours is more often, rather than not is met with disencouragement. What use of rightness is when the suggested ways of living propose to us a view neither veritas, nor aleithia—below our feet, but a thick layer of smog and gas. Get used to the machinery, it’s here to stay.
Suddenly, time was no more
Blockchain is not else, but history, and struggles of Blockchain adoptation are akin to struggles history had experienced since the dawn of time. If you think about it, blockchain ledger is not really a transaction table neither it a log of events, but a play. The roles are clearly defined, and so are the rules. Everybody is speaking whenever they can and should. There sure are uncivilised men: manipulators, spammers, hecklers. They are kept at bay. To me this roughly what history is, in the sense that we’re taught since from when growing up: treating the past as a collection of texts in the form of discourses: a huge, chaotic play, full of uncertainty and tension. But it doesn’t have to be so. Some histories are much better off in themselves to be certain, such as financial ledgers, for example. One reason for that is that people do like their money. Not because they are particularly fond of it. In fact, most if not all people detaste money, therefore precisely because of that, the perversion inevitably arises when it’s no longer a despicable means of power, but a self-object of desire. Listen to what Zizek says, jokingly, about bankers. Bankers! They took all of our money and make us all look like fools! And all the rich boys with their fortunes laying cold abroad on sweet 2% a year… And oh, by Zeus, there’s absolutely nothing accidental about that!
We read history just like we read texts, so there really shouldn’t be much difference. Why not treat our systems likewise? It’s only a matter of getting the language right, and then after some time, the methodology of translation will be established. In one way or another, we would need to understand the language, by which machinery in the pillars of our world operate, translate it back-and-forth against the natural language. Boom! For very very lots of things, we might not require a myriad of highly-specialed technologies or calculus. For certain things, a language interface should suffice—to correspond the deed to the computation of it, whenever this is required.
Once again it must seem I’m only but dipping my hands in the sand and desperately trying to reason about my notation, which I really believe is worth reasoning about. Think about it, and I will be very pleased with you—to learn from. Going further back to what I was saying, Language decidedly can’t be the heart of the matter, it must undeniably be Man, or at least God. We’re alike, anyway, to the point this doesn’t matter. What does matter, thought, is the extent to which languistic concepts can be extended into other areas of thought, and the real world. I am myself very interested to figure out the language of machinery, but this in no way means I wish to have a chat with a bloody kettle! Once something is said, it either matters or it don’t—in the long run. Either way, at some point we’re bound to look deeper and resort to means of history: looking at various discourses, contraposing them in order to substract all of the imaginary and keep all of the real. For this to be possible, systems must be viewed as their histories, and treated as texts, a series of meaningful assersions, making clear of what’s in the state is being mutated.
From this view, the introduced notation offers a unique possibility to use a single grammar to express both the language of the target discourse, and all the possible states of the affairs, emerging from the discourse, as it unfolds in time, akin to a play. Consider merchant discourse, used as an example earlier on: it could easily correspond to the following history:
<John Doe>: Buy Hair dryer for 2 Cupboard from <Jeremy>! Buy Car for Hair dryer from <Idiot Jamie>! <Idiot Jamie>: Sue <John Doe> for fraud!
The sueing part isn’t necessarily sensical, but you should get the point. The biggest advantage of having the sytem described by its language is that it instantly allows you to think of state as discourse, and of transactional state changes—as distinct propositions, or even texts, uttered by actors.