BinaryAlphabet()
For all purposes, the BinaryAlphabet class works as a wrapper for a String array of two elements. The existence of such a class may seem redundant, even inappropriate. However, if the purposes of the Library are to be taken seriously, addressing what it entails to have a collection of at least two distinct ‘things’ is paramount. Let us then start by addressing how the BinaryAlphabet class can be used.

CLASS CONSTRUCTORS


BinaryAlphabet(String c1, String c2);
BinaryAlphabet(String c1, String c2, Log L);
BinaryAlphabet(String[] c);
BinaryAlphabet(String[] c, Log L);

A BinaryAlphabet object can be instantiated by calling one of the class constructors and passing on arguments in one of the two following manners: either pass two separate Strings to be used, respectively, as the alphabet’s first and second characters or pass a String array with exactly two elements to make up for the alphabet’s two characters. Both cases require each character to be different from one another. Additionally, for each modality, a Log object can also be passed as an argument so that the object may print internal information to the Synthax Log window during execution. 

CLASS METHODS


void update(String c1, String c2);Updates the alphabet with two new characters, passed as two separate strings.

void update(String[] c);Updates the alphabet with two new characters, passed as a String array. 

void logProperties();As long as a Log object has been passed as an argument to the class, the method prints the object’s internal information to the Synthax Log window.
 
String[] getAlphabet();Returns the binary alphabet as a String array;

String getCharacter(int i);Returns the alphabet’s character stored at index i;

Now, what is the purpose of such a redundant class? From a technical perspective, none. The pertinence of the class may find a more solid justification if framed within the library’s architecture, but even then, a simple two-element String array would perform better. The reasoning behind the class construction stems from a need to underline “distinction” as a core mechanism of symbolic systems.

If we were to build a representational system from scratch, the first thing we could do would be to endow that system with a symbol. Let us use the term symbol as informal parlance for a 'thing' of any embodiment that points to, refers to, stands for, represents, denotes or identifies something else. Within the world constructed by such a system, 'all that there is' would be represented by that same symbol, which is to say that 'all that there is' is that symbol. Stepping outside our system's world and into another that would, in some way, encompass it — we can use a version of what is commonly pointed to by the expression 'our actual world' for our purpose — we would realise that within the former, our symbol would denote the letter 'x', and also the letter 'y'. The title phrase 'Moby Dick', the whole text that makes up the novel denoted by that title, and all of its printed copies, alongside its characters and author, would also be referred to by our single symbol. One would think that since all of the characters that make up the Latin alphabet were to be denoted by our symbol, then the sentence ‘Call me Ishmael’ would be denoted by a string of 15 embodiments of our symbol — one for each Latin character. That would already be too much for our system. ‘C’ would certainly be denoted by our single symbol. The letter ‘a’ as well. But as soon as one would try to compose the Latin characters into the sentence, one would realise that: 

‘C’ Our Symbol;
‘Ca’ Our Symbol;
‘Cal’ Our Symbol;
‘Call’ Our Symbol;
‘Call ’ Our Symbol;
‘Call m’ Our Symbol;
‘Call me’ Our Symbol;
‘Call me ’ Our Symbol;
‘Call me I’ Our Symbol;
‘Call me Is’ Our Symbol;
‘Call me Ish’ Our Symbol;
‘Call me Ishm’ Our Symbol;
‘Call me Ishma’ Our Symbol;
‘Call me Ishmae’ Our Symbol;
‘Call me Ishmael’ Our Symbol;

Let us then pretend the single symbol of our system to be the ⟨m⟩-mark. Notice that, within our domain,  ⟨m⟩ is not the letter 'm', nor any other of the infinite connotations one can recall or conjure for ⟨m⟩. ⟨m⟩ is the actual mark, the ⟨m⟩-shape. As soon as such a choice is made, one realises our system to be insufficient, for if 'all that there is' is denoted by  ⟨m⟩, then distinguishing one thing from another — distinction in itself — is, as we saw, beyond our reach. Using the ⟨m⟩-mark as a symbol implies distinguishing ⟨m⟩-marks from non-⟨m⟩-marks. Since our system 'knows' just one 'thing', and conversely, for that system, 'all that there is', including ⟨m⟩ and not-⟨m⟩, is that same 'thing' — ⟨m⟩. We would then need to build a meta-system to sort ⟨m⟩-marks from non-⟨m⟩-marks. This meta-system would then need to be endowed with two symbols — one to denote ⟨m⟩-marks and another for non-⟨m⟩-marks — let us use ⟨x⟩ and ⟨y⟩ respectively —; and a set of rules to discern if a given mark could be classified as a ⟨x⟩, a ⟨m⟩-mark, or ⟨y⟩, not a ⟨m⟩-mark. Surely, in turn, the meta-system would need its meta-system — a meta-meta-system — capable of writing such rules. The following diagram maps out a possible symbolic integration of these systems, with our original system typed in blue, the meta-system in black, and the meta-meta-system in grey.

if( ⟨m⟩ is ⟨x⟩ ) do write ⟨m⟩;
else if ( ⟨m⟩ is ⟨y⟩ ) do nothing;

This line of reasoning would lead us into discussing grammars, recursivity and meta-languages. However, for now, it is sufficient to focus on the foundational ability of identifying and thus making distinctions — to distinguish one 'thing' from another. Equipped with our meta-system, one would be able to classify things as either ⟨x⟩ or ⟨y⟩. Now, it may seem that  ⟨x⟩ and ⟨y⟩ would not need to be oppositional, and that is true in some sense. One could establish an identity relation between ⟨x⟩ and 'bird' and between ⟨y⟩ and 'mammal'. However, how should one proceed when facing a reptile? It is not a bird nor a mammal, so it is not-⟨x⟩ and is not-⟨y⟩. Our meta-system would again need a meta-system of its own to classify if something is either an ⟨x⟩ or a ⟨y⟩ — ( x || y ) — and not something else — ~( x || y ). It would be easier to have ⟨x⟩ and ⟨y⟩ be oppositional so that what is identified as ⟨x⟩ can not be identified as ⟨y⟩, and vice-versa, and that ‘all that there is’ is either exclusively an ⟨x⟩ or exclusively a ⟨y⟩. Returning to our example, if ⟨x⟩ were to denote 'bird' and ⟨y⟩ 'not bird', 'all that there is' would be either a ‘bird’ or not a ‘bird’, and thus, although rudimentarily, everything would be accounted for within the system. Binary distinctions are certainly crass simplifications, but we must start somewhere, and some degree of simplification is always at play in any representational system.

At least two symbols are needed for a system to express distinctions. The collection of symbols used by a system is called the system's alphabet. A system with just two symbols is a binary system and, as such, has a binary alphabet. The usage of ⟨0⟩s and ⟨1⟩s is a common standard for binary systems, alongside ⟨true⟩ and ⟨false⟩, ⟨on⟩ and ⟨off⟩, or ⟨high⟩ and ⟨low⟩. However, beyond entrenchment, these marks bear no specific properties that would preclude any other mark from being included in a binary alphabet, as long as the binary symbols making up the alphabet are distinct from one another:  ⟨yellow⟩ and ⟨hello⟩, ⟨water⟩  and ⟨dog⟩, ⟨3⟩ and ⟨$⟩, Kipling's ‘If’ and Musil's ‘The Man Without Qualities’.

( … )