Thoughts on Intercommunication: Symbols

Following my previous thoughts on intercommunication is the expansion for that proposed system which
can transfer integers of any length, to a system which can transfer symbols as well.  Obviously true
is that symbols, meaningless data to which meaningful data may be attached, should be transmitted as
integers too.  It's also clear that the symbols are distinct from integers primarily in what may not
be done to them; symbols may be compared, and nothing else; from comparison comes the ability to map
symbols to data and vice versa by search in other data.  Without such data, symbols are meaningless.

A type system is required to distinguish integers from anything else, and this is the primary issue;
a type system code should be an integer too, and the question of whether it should use the most pure
integer representation or the same representation as every other integer is mostly uninteresting and
leaning towards the latter choice.  The issue is what such codes should represent; I see no solution
beyond requiring every party to know their meanings beforehand, which poses the issue of which codes
should be more primitive than others.  Integers, integers with a sign, and collections are certainly
primitive enough, but if symbols are is unclear.  The method of object orientation can be applied to
self-describing data, but that's only possible with a system to represent code underneath such data.

For a collection to have clear boundaries, it must have both a beginning and an end, and this is the
primary problem in designing the numerical representation of such a data structure.  The obvious fix
is to have such a structure consist of an integer stating the length, but this requires such lengths
to be known ahead of time, which may be impossible or undesirable.  My first thought to address this
is using the zero length to indicate such, and then using a digit to signal elements in the same way
the integer representation signals its representation.  The only issue with this scheme is lacking a
means to represent an empty collection, but a type system code specifically for that solves it well.

The representation of collections can be optimized for different goals, and it's unclear which level
should have which optimizations.  A collection could store one type code for all of its elements, or
a bit size to which all elements must adhere, but both of these seem more suited to some next level.

The one good solution I currently see is every discrete message in such a computer network having an
integer at the beginning to indicate its schema, which would be this implicit mapping of type system
codes to primitive types with their implicit representations; this is unsatisfying to me, because my
purpose in thinking about computer networking so was to arrive at something less arbitrary, and more
pure, but my conclusion can be only that not one approach seems to be undeniably desirable for such.

The thought of ASCII, Unicode, and similar garbage persisting for centuries is one deeply troubling.

I'm inclined to believe that the architecture of the Internet is mistaken and inadequate, even after
ignoring the several uncorrectable design flaws it has related to trivial resource attacks.  Perhaps
the ideal are networks based on fixed-length messages defined with no possible ambiguities under any
possibility, and diversity of networks; after all, replacing the telephone network with the Internet
resulted in a shitty telephone network which can't possibly match the quality of what had once been.
.