This document is a well-annotated logotic text.
There is very little difference as to how we read history, write text, or design computer systems. In a way, there is no difference at all; as long as you think of system in terms of text, history remains a matter of time.
Logos is not a programming language, but a language language.
Therefore, it does not attempt at programming, but rather allows for elaborate description and interpretation of arbitrary systems.
Whenever a sign occurs, we are tempted to compute it.
In programming, this is not necessarily the most sensible thing to do, in which case it soon becomes apparent that for certain problems no amount of additional programming will be sufficient to interpret the sign.
// 1. Void manifests itself. // void.
To speak of
void is to say nothing.
// 2. Iota is an intangible particle, a form distinguished from void. // iota := not void.
iota signifies meaning,
void a lack thereof.
The occurance of
iota is inevitable in any meaningful discourse; to remain meaningless the discourse has to consist of either one or none propositions.
// 3. Boolean is a iota of truthfulness. // boolean := iota. // 4. True and false are the boolean possibilities. // true, false := boolean. // 5. Truthfulness gives rise to normal logic. // 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.
The aforementioned propositions express the foundation of logic.
It’s about time to elaborate upon the rules more. Much of the logotic syntax is driven by punctuation. By now, you could have guessed correctly that
:= reads as “say” and plays the semantic role of definition.
You can spot a couple of extra punctuations, such as propositional implication
-> and the questional
? along the lines of the definition above. Exact definitions of these punctuations are irrelevant in due course of this specification, so no need to bother demonstrating their significance.
// 6. Exclusive is derived from the existing propositions. // p xor q := p, q := boolean. -> (p or q) and not (p and q.)
Exclusive or—logical addition—can be expressed with the propositions beforehand.
This should be absolutely clear!
When speaking of discourse, it’s important to remember that discourse is not whole in the same way a word is whole. For discourse, one shall constantly differentiate the object—language that is being used, from the subject—participators of so said discourse.
No programming language makes explicit distinction between the object and the subjects of discourse.
// 7. Text is a non-empty sequence of propositions. // text := iota...
There are many theories of language, but it’s fair to consider words atomic and think of propositions as consisting of words.
Proposition in itself is only a statement of fact about the world. Deprived of context, that is—state of the affairs—it becomes somewhat atomic, too. Text is to a proposition what proposition is to a word.
… punctuation is used to pronounce the text.
// 8. Actor is a iota of the subject. // actor := iota. // 9. This is the currently speaking actor. // this := actor. // 0. If-then-else text clause construction. // if condition, then clause := condition := boolean. clause := text. condition -> clause... -> conditions. condition else alternative clause := condition := boolean. alternative clause := text. not condition -> alternative clause... -> condition? // 9. For a sign, we can speak of its value. // sign is defined := sign := iota. -> sign != void.
Whearas propositions simply consist of words, discourse doesn’t exclusively consist of texts, but also includes the ones pronouncing these texts in due course.
Dialect is a description of what can be said by whom under what circumstances.