Ian Byrd

On language, history and system design

It’s no 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. 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 to see 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.


The wild winds weep,
And the night is a-cold;
Come hither, Sleep,
And my griefs enfold! …
But lo! the morning peeps
Over the eastern steeps,
And the rustling beds of dawn
The earth do scorn.

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,

Like a fiend in a cloud,
With howling woe
After night I do crowd
And with night will go;
I turn my back to the east
From whence comforts have increased;
For light doth seize my brain
With frantic pain.

~ 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 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.

// Void manifests itself.
void

// Iota - an intangibly small particle,
// naturally distinguished from void.
iota := not void

Void here symbolises infinitely big, and iota stands for 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 signs will be derived from it. One of the possible distinctions to be made is that of truthfulness and the two boolean possibilities, true and false.

// Boolean sign is a iota of truthfulness.
bool := iota

true, false := bool

So far I’ve only used := as to say about signs, but apart from signs we must specify how these signs ought to be used, e.g. define propositions in which these signs occur. In my notation, propositional form can be described with an arbitrary set of signs, such is +, !, -, 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 signs.

not p :=
	p := bool
	-> p =
		true  -> false
		false -> true

p and q :=
	p, q := bool
	-> p =
		true  -> q
		false -> false

p or q :=
	p, q := bool
	-> 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 of 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 := bool
	-> (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 t..., 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.

// Text is a non-empty series of propositions.
text := iota...

if p, then q :=
	p := bool
	q := text

	p = true -> q...
	-> p

p else q :=
	p := bool
	q := text

	p = false -> q...

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 truth and 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 by ::, 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:

int ::
	int + int -> int
	int - int -> int
	int * int -> int
	int / int -> int
	// comparison, mod, etc. operations follow

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 would include mod, >, or >=. Make notice not to mistake for grammar the nonsensical parts of propositions, signs like + and -. 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, :: or -> are part of the grammar, in themselves punctuation, intended to indicate a notion of showing or following, correspondingly, while + and - are not punctuations, but signs themselves. signs, described by the means of this grammar, on their own nonsensically shaping the proposition form. 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 elementary 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 the elementary 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 sign, that would make a stock for each of the goods:

// This sign is composed of others.
Merchant :=
	Apples (int)
	Oranges (int)
	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.

item "list" ::
	item := iota
	position := int

	// retrieving item by its position
	position at list -> item
	item in list -> bool
	list length -> int
	item in list -> int
	// find first occurance
	search item in list -> position
	// manipulations
	append item to list!
	insert item to list at position!
	remove from list at position!

swap i and j of list :=
	list := iota list
	i, j := int
	i at list, j at list -> j at list, i at list

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 mapping correspondence as well, or as it’s often called, 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:

key "map" of value ::
	key, value := iota

	map of key -> value
	key in map -> bool
	insert key into map!
	remove key from map!

As you can see, the form of dictionary sign is rather complex, thus in order to concisely formulate, an indicative, "map" 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 weems 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
Apple, Orange, Banana := Commodity

Merchant :=
	Beneficiary (actor)
	Goods (Commodity list)
	Price

// The form indicates a map, Commodity -> int.
Merchant.Price :=
	Apple -> 1
	Orange -> 2
	Banana -> 4

// Only propositions ending in an exclamation mark can mutate the 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.

actor := iota

// `This` is always the one who speaks.
this := actor

As in the case of bool, 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 distinct actor signs, but as every other sign, actor can be shown to be or not to be equal to the other actor, allowing for proposition form a = b, where a and b are actors, even though my notation doesn’t specifically distinguish between different actor signs.

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.

Merchant has some of these :=
	some := int
	these := Commodity
	total := count these in Merchant.Goods
	-> total >= n

Merchant rate on something :=
	something := Commodity
	-> Merchant.Price of something

buy tit for some tat from seller! :=
	tit, tat := Commodity
	some := int
	seller, buyer := Merchant, this of Merchants

	enough := some * (seller rate on tat) / (seller rate on tit)
	buyer has some of tat
	seller has enough of tit
	// 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 treat history just like we treat 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.

TBA