The F.E.D. Psychohistorical-Dialectical 'Meta-Equation' of Human-Social Formation(s) 'Meta-Evolution'.
Part III. B.: Interlude. The Dialectic of 'Modern Computerware'.
The Systematic Dialectic of 'Modern Computerware' --
Systematically Presented via a 4-Symbol Expression.
Dear Reader,
This model is a bit more
challenging than the model of “TV-Series”, presented earlier in this series,
but only because it requires some “domain-expertise” -- or, at least, some
“domain familiarity” -- with respect to the domain of modern electronic digital
computer systems -- both hardware systems and software systems.
We will, in this post, use
the F.E.D.
‘first dialectical algebra’ to construct, and to “solve”, a “heuristic”,
‘intuitional’ model of a systematic presentation of the domain of ‘modern
computerware’ -- encompassing core aspects of both its hardware and its software
sub-domains.
Herein we mean, by the word,
‘‘‘systematic’’’ in the phrase ‘‘‘systematic presentation’’’, a presentation of
the major kinds of “entities” that exist in this domain -- by means of
categories that classify those entities by their “kinds”, i.e., as ‘‘‘ontology’’’,
or as “kinds of things” -- in strict order of rising complexity,
starting from the simplest category, and moving, step-by-step, from lesser to
greater complexity, until we reach the most complex category for this domain,
or for the purposes of this example.
The model that we will build
will generate these categories in that strict, systematic order of rising
complexity.
This will be a “snapshot”
model, a “synchronic”
model that takes the contemporary slice of time -- or at any rate, a recent-past
slice of time -- and algorithmically generates descriptions of categories for
entities that presently exist, or that might presently exist, for the model’s
domain, in their systematic order, as described above.
Our model here will not be a “chronology” model, or “diachronic”
model, like the previous, major model, narrated in this series, in which the
units of earlier categories are described as actually, e.g., physically,
constructing,
through their activity
as “causal agents”, or “subjects”, the units of later
categories, categories whose units did not
exist until that construction took place. That is, it will not be a model of a ‘self-advancing’
historical progression of ontology, with
each historical epoch containing both old ontology, inherited from past
historical epochs, and new ontology, ontology that had never appeared before -- in past historical epochs -- until the later epoch in
question.
We will apply a documented, standard
procedure
to “solve” this model -- to determine what actual category each of these
generated category-descriptions refers to, and to determine which, if any, of
these category-descriptions describe “empty categories”, i.e., represent
‘combinatorially’ possible entities that actually do not exist for
this domain -- at least not presently.
Regards,
Miguel
Regards,
Miguel
To get started, we must determine the starting-point -- the point-of-departure -- for our systematic model.
This starting category will
be the seed of our whole progression of generated 'category-descriptions',
influencing every 'category-description' that follows, as the “controlling source” and as the
“ever-present origin” of all that follows from it.
The rule for getting started
is to ask oneself “¿What is
the least complex kind of thing, the simplest kind of thing, which
exists in this domain?”
-- in our case, in the domain of ‘modern computerware’ -- and to then find the
answer to that question, based upon one’s prior knowledge of, or familiarity
with, this domain.
The answer to this starting question that we will pursue in this example is the following: The “bit” is the simplest ancestor, the ultimate unit, of modern, electronic, digital ‘computerware’, ingredient in every one of the more complex units of that domain.
Single, circuit ‘on’-or-‘off’,
‘1’ or ‘0’, digital,
Boolean, binary, base 2 arithmetic “bits”
will be our base units.
Therefore, the category which
we shall name bits is our starter category,
and we shall symbolize it, in our specific
category-algebra model, via the second letter of that name, as i, or as qi, identifying that specific category with the generic
first category symbol of our generic
category-arithmetic model, namely, the symbol q1, in an identification, “interpretation”, or “assignment”
[ ‘[---)’ ] that we indicate by writing: i = qi [---) q1.
Our model then, will be an
equation, that looks like this --
)-|-(s = i2s = bits2s
-- with the variable s indicating the step in our systematic presentation that the
‘accumulation of categories’, denoted by )-|-(s, represents.
Stage 0. Our initial step -- step s = 0 -- contains only our starting category, i = qi --
)-|-(0 = i20 = i1 = i
because 2 “raised” to the power 0 -- 20 -- is just 1, and because i
“raised” to the power 1 is just i.
Stage 1. It is when we
get to step s = 1 that our
equation-model gives us something initially “unknown” -- and, therefore,
something ‘‘‘algebraical’’’, not just ‘‘‘arithmetical’’’: something to “solve-for” --
)-|-(1 = i21 = i2 = i x
i = qi x qi = qi + qii = i + qii
-- because 2 “raised” to the power 1 -- 21 -- is just 2, and because our rule for multiplying a generic
category, call it qx = x, “by”, or “into”, itself, is, simply:
qx x qx = qx + qxx = x + qxx.
qx x qx = qx + qxx = x + qxx.
Herein, q is the generic
category ‘qualifier’. The subscripts that come after it are specific category descriptors.
¿But how do we determine what the resulting, initially
“unknown” category, or ‘category-description’, here qii, means?
Well, the generic rule to “solve-for” the
categorial meaning
of such symbols is that, if we know what is meant by category qx = x, then the symbol qxx describes a category each of whose units is an ‘x OF xs’, that is, a category for a different kind of units, called ‘meta-xs’, each
such unit being made up out of a multiplicity of xs.
To be specific with this rule, qii specifies a category each of whose units is a ‘bit OF bits’, that is, a ‘meta-bit’, such that each ‘meta-bit’
is made up out of a multiplicity of bits. Our experience of ‘modern computerware’
suggests that such units do indeed presently exist.
That category-description
describes the category of ‘multi-bit’ units -- of bytes, i.e., of computer characters, such as ASCII characters -- which we therefore
symbolize, again, via the second letter of its name, by y.
We may “assert” our solution
as follows: qii = qy = y [---) q2.
Again, what is dialectical about the
relationship between i and i2, or i x i, or ii, or i of i, or i(i), the relationship of what we call ‘meta-unit-ization’, or ‘meta-«monad»-ization’,
between i and its already presently existing, ‘supplementary other’, y, is that this relationship is a synchronic
«aufheben»
relationship: each single unit of the bytes
category is a negation,
and also a preservation,
by way of also being an elevation
to the / forming the bytes category / level / scale, of a whole [sub-]group of
units
of the bits category /
level / scale.
So, our full solution to the step s = 1 equation of our model is --
)-|-(1 = i + y = bits + bytes.
If this model is working
right, bits will be the simplest
category of the domain of ‘modern computerware’, and bytes
will be the next more complex
category of that domain.
Stage 2. ¿What ‘category-specifications’ do we
generate in our next step, step s = 2, that need “solving-for”?
Let’s find out:
)-|-(2 = i22 = i4 = ( i2 )2 = ( i + y )2 = ( i + y ) x ( i + y ) =
i + y + qyi + qyy.
i + y + qyi + qyy.
This result arises by way of
two key rules of categorial algebra, plus the general rule for multiplication when one category is
multiplied by a different category [we used a special case of this general
rule, for the case where the same category is multiplied by itself, in step s = 1, above] --
1. qb x qa = qa + qba = a + qba; special
case: qb x qb = qb + qbb = b + qbb.
2. qa + qa = qa; the same category, added to itself, does not make
“two” of that category; one “copy” of each category is sufficient; two or more
copies of any category would be redundant.
3. There is no qx such that qa + qb = qx; different categories, added together [as
opposed to being ‘‘‘multiplied’’’], do not reduce to a single category, as in
the proverbial ‘apples + oranges’, or a + o.
Well, we already know how to
“solve-for” qyy.
It describes a category of ‘bytes OF bytes’ -- a category each of whose units is a ‘byte OF bytes’, i.e., each of which is a ‘meta-byte’, such that each such ‘meta-byte’ is made up out of a multiplicity of bytes.
Our experience of ‘modern computerware’ suggests that such units do
indeed presently exist.
That category-description
describes the category of ‘multi-byte’ units -- of computer “words”, e.g.,
the components of a computer-program’s commands -- which we therefore
symbolize, this time via the first letter of its name, by w.
We may “assert” our solution
as follows: qyy = qw = w [---) q4.
Our step s = 2 equation-model, as we have solved it so far, thus now
looks like this --
)-|-(2 = i22 = i4 = i
+ y
+ qyi + w
[Note emerging pattern: i2 generates 2 categories, i4, 4 categories]
[Note emerging pattern: i2 generates 2 categories, i4, 4 categories]
-- since we still have not yet
determined which actual category of the ‘modern computerware’ domain is
described by the algorithmically-generated symbol qyi -- if any, i.e., if qyi is not an “empty category” for this domain.
When, as a component of ( i + y ) x ( i + y ), the
“higher-complexity” category, y, operates
upon / “multiplies” the “lower-complexity” category, i --
y x
i = i
+ qyi
-- generically speaking, the categorial relationship
to be called to the user’s attention by this operation, in this ‘categorial
arithmetic’, is, again, a synchronic
«aufheben»
relationship, this time between i and qyi.
It calls the user to search that user’s knowledge and memory of the domain in question -- in this specific case, the domain of ‘modern computerware’ -- for a category which represents an “uplift” of category i entities to the level of the entities native to category y, thereby “canceling” the i-type entities concerned, at their own native level, but, by the same token, “preserving” those “special” category i entities that qualify for this “hybrid” category, combining y and i qualities, in the relationship of “elevation” of those category i entities within the level typical of category y entities.
Thus, the additional category thereby presented, qyi, signifies exceptional i units, that “double as” y units, or that “masquerade as” y units, or that “exist in the way that, normally, only y units exist”.
It calls the user to search that user’s knowledge and memory of the domain in question -- in this specific case, the domain of ‘modern computerware’ -- for a category which represents an “uplift” of category i entities to the level of the entities native to category y, thereby “canceling” the i-type entities concerned, at their own native level, but, by the same token, “preserving” those “special” category i entities that qualify for this “hybrid” category, combining y and i qualities, in the relationship of “elevation” of those category i entities within the level typical of category y entities.
Thus, the additional category thereby presented, qyi, signifies exceptional i units, that “double as” y units, or that “masquerade as” y units, or that “exist in the way that, normally, only y units exist”.
For example, if we were doing a systematic model of written English, with L denoting the category of Letters of the English alphabet, and with W denoting the category of written English Words, then the category-symbol qWL would stand for the category of individual English Letters that also qualify as English Words, e.g., ‘a’ and ‘I’.
In this specific case, this means that a unit
of the qyi category is a bit
unit that passes for a byte unit.
¿Do any such units presently exist, in the domain of
‘modern computerware’?
¿E.g., are there any computer programming languages in
which a single bit unit can mimic
a whole byte unit?
Yes -- F.E.D. research has identified, we believe, specimens of
just such entities, e.g., the link --
-- links to a circa 1981 paper by Thomas D.
Frank, entitled “Comprehensive Geo-Data Base Control with an Electronic
Coordinate Digitizer”, that states the following [p. 500]: “Bitplane data organization records
only the presence or absenceof a particular attibtute. An element of the geo-referenced data
structure is encoded with a “one” or a “zero” to indicate the presence or
absence, respectively, of the attribute in that element. One bitplane is stored for each data
value or class for each category.
Although a relatively large number of individual bitlane files might be required for a large
number of categories and classes, the small size of each file makes an
efficient data organization (binary structures can be stored as one-bit bytes).”
Were we to find no instances
of such units in present existence, then “category” qyi might be an instance of the generic “empty category”, denoted . -- connoting “full zero”, or “existential zero” --
for this particular domain, and we might, in that case, “assert” our solution
as follows: q3 (---] qyi =
. [---) q0.
. [---) q0.
We might therefore write our full
solution for step s = 2 as --
)-|-(2 = i22 = i4 = i + y + qyi
+ w = i
+ y
+ . + w = i
+ y
+ w =
bits
+ bytes
+ words.
But let’s keep our
‘categorial-combinatorially possible’
category qyi around, since I believe that we have found a specimen just such an entity in
our research, just summarized above --
)-|-(2 = i22 = i4 = i
+ y
+ qyi + w.
Stage 3. ¿What ‘category-specs.’ do we generate
in our next step, step s = 3, that need
“solving-for”?
Let’s see:
)-|-(3 = i23 = i8 = ( i4 )2 = (i + y + qyi + w) x (i + y + qyi + w) =
i + y + qyi + w
+ qwi + qwy
+ qwyi + qww.
We know -- from past
experience, narrated above -- how to “solve-for” qww.
It describes a category of ‘words
OF words’
-- a category each of whose units is a ‘word OF
words’, i.e., each of which is a ‘meta-word’,
such that each such ‘meta-word’ is made up out of a multiplicity of at
least two words. Our experience of ‘modern computerware’
suggests that such units do indeed presently exist.
That ‘category-description’
describes the category of ‘multi-word’ units --
of computer “commands” -- the components of a computer-program, e.g., for a
minimal, “unary”, operator command, with at least one word
representing the “operator” or “function” of that command, and operating
upon at least one other word as the “operand” or “argument” of that command
-- which we thus symbolize, via the first letter of its name, by c.
We may “assert” our solution
as follows: qww = qc = c [---) q8.
Our step s = 3 equation-model, as we have solved it so far, thus now
looks like this --
)-|-(3 = i23 = i8 = i + y + qyi + w
+ qwi + qwy
+ qwyi + c
[Note: i8 generates 8 categories]
[Note: i8 generates 8 categories]
-- since we have not yet determined
which actual categories of the ‘modern computerware’ domain are described by
the algorithmically-generated ‘category-description’ symbols qwi, qwy, and qwyi, if any.
But we already know how to
characterize the possible
categories that these 3 category-symbols “call for”, viz.:
·
qwi [---) q5 “calls for” the category of a kind of bit units that stand
in for computer word units.
·
qwy [---) q6 “calls for” the category of a kind of byte units that
stand in for computer word units.
·
qwyi [---) q7 “calls for” the category of a kind of qyi units that
that stand in for computer word units.
¿Do any such units presently exist, in the domain of
‘modern computerware’?
·
¿Are
there any computer programming languages in which a single bit unit can function
as a whole word?
Specimen: Patent US4099253A, 14 July 1978, Phillip G. Dooley, Jr., “Random access memory with
bit or byte addressing capability”: “...some data is preferably handled in the
form of multi-bit words or bytes and other data is preferably handled in the
form of single bits (one-bit words).”
[Abstract] -- https://www.google.com/patents/US4099253
.
·
¿Are
there any computer programming languages in which a single byte unit can function
as a word?
Specimen: The
article “Deconstructing Google” states the following “For the common one-byte words,
we can build an array, the nth element of which indexes into the big array to
get immediately to the place where the sum is n2.” [p. 1] -- http://www.cap-lore.com/code/DecGoogle.html
.
·
¿Are
there any computer programming languages in which a single qyi unit can function
as a whole word?
Were we to find no instances
of such units in present existence, then the “categories” qwi, qwy, and qwyi, and might all be instances of the generic “empty category”, . , and we might “assert” our solution as follows:
qwi = qwy = qwyi = . [---) q0.
We might therefore write our full solution for step s = 3 as --
)-|-(3 = i23 = i8 = i + y + qyi + w
+ qwi + qwy + qwyi + c =
i + y + . + w
+ . + . + . + c =
i + y + w + c =
i + y + w + c =
bits
+ bytes
+ words + commands.
But let’s keep all of our
‘categorial-combinatorially possible’
categories around for a while longer, since we have already found specimens of qwi and qwy in contemporaneous existence --
)-|-(3 = i23 = i8 = i
+ y
+ qyi + w
+ qwi + qwy + qwyi + c.
The model up to and including step s = 3 can be summarized pictorially as follows --
Stage 4. ¿What ‘category-descriptions’ do we
generate in our next step, step s = 4, that need
“solving-for”?
We generate the following
old/new categories/‘category-descriptions’:
)-|-(4 = i24 = i16 = ( i8 )2 = (i + y + qyi + w
+ qwi + qwy + qwyi + c)2 =
i + y
+ qyi + w + qwi + qwy + qwyi + c + qci
+ qcy
+ qcyi
+ qcw
+ qcwi + qcwy + qcwyi + qcc.
We know how to “solve-for” qcc.
It describes a category for ‘commands
OF commands’
-- a category each of whose units is a ‘command OF
commands’, i.e., each of which is a ‘meta-command’,
such that each typical such ‘meta-command’ is made up out of a multiplicity
of commands. Our experience of ‘modern computerware’
suggests that such units do indeed presently exist.
That category-description
describes the category of ‘multi-command’ units
-- of computer “programs” -- which we therefore symbolize, via the first
letter of its name, by p.
We may “assert” our solution
as follows: qcc = qp = p [---) q16.
Our step s = 4 equation-model, as we have solved it so far, thus now
looks like this --
)-|-(4 = i24 = i16 =
i + y
+ qyi + w + qwi + qwy + qwyi + c + qci
+ qcy
+ qcyi
+ qcw
+ qcwi + qcwy + qcwyi + p
-- since we have not
determined which actual
categories of the ‘modern computerware’ domain, if any, answer to the ‘combinatorially’ possible, mechanically-generated
symbols qci, qcy, qcyi, qcw, qcwi, qcwy, and qcwyi.
But we do know how to characterize the possible categories that these seven category-symbols “call for”, viz.:
But we do know how to characterize the possible categories that these seven category-symbols “call for”, viz.:
·
qci [---) q9 “calls for” the category of a kind of single bit units
that function as command units.
·
qcy [---) q10
“calls for” the category of a
kind of single byte units that function as command units.
·
qcyi [---) q11
“calls for” the category of a
kind of qyi units that
function as command units.
·
qcw [---) q12
“calls for” the category of a
kind of single word units that function as command units.
·
qcwi [---) q13
“calls for” the category of a
kind of qwi units that
function as command units.
·
qcwy [---) q14
“calls for” the category of a
kind of qwy units that
function as command units.
·
qcwyi [---) q15
“calls for” the category of a
kind of qwyi units
that function as command units.
¿Do any such units exist, in the domain of ‘modern
computerware’?
·
¿Are
there any computer programming languages in which a single bit unit functions
as a command unit?
Specimen: From
the University of West Australia, instructor John Morris’s 1997 “Objects First” Lab. Assignments 2 & 3, regarding a “Lift Controller”, contains the
following description: “The
CSCC163 lift simply has one-bit commands to tell the lift to go up or down and to light the
indicators at the top or bottom.
There is a further bit which rings a bell. It inputs dingle bits which tell it: 1. that the lift is at the top or bottom, 2. that the top or bottom request button has been pressed...”
-- http://www.ee.uwa.edu.au/~roberto/teach/morris/Year1/CLP110/Labs/ass2_97.html
.
·
¿Are
there any computer programming languages in which a single byte / single character unit functions
as a command unit?
Specimens: The
article entitled “Getting Gmail working well with speech commands”, by Kimberly Patch, opens as follows: “If you haven’t
used speech commands to control a computer, it might not be obvious that single character commands, for
instance, “y” to archive a message in Gmail, can present a challenge. Single-character commands seem like a great idea, especially for Web programs,
because your Web browser already takes up some common keyboard shortcuts. Gmail has a lot of single-character commands,
and once you get to know them you can fly along using the keyboard. In general I’m all for more keyboard
shortcuts because it’s easy to enable them using speech. Single-character commands
that can’t be change, however, can get speech users in a lot of trouble. ... .”
[p. 1, emphases added by M.D.] -- http://www.redstartsystems.com/blog/category/speech-commands/
.
The Wikipedia entry for the
“ancient”/famous TECO “Text Editor and COrrector” [originally “Tape Editor and COrrector”], originally
developed by MIT in the 1960s, describes the subject software application in
the following terms: “TECO does
not really have syntax; each character in a program is an imperative command,
dispatched to its corresponding routine. ... Despite the odd syntax, the TECO command language was
tremendously powerful, and clones are still available for MS-DOS and for
Unix. TECO commands are characters
(including control characters), and the prompt is a single asterisk: ... .”
[pp. 1, 4, emphases added by M.D.] -- http://en.wikipedia.org/wiki/TECO_(text_editor) .
·
¿Are
there any computer programming languages in which a single qyi unit functions
as a command unit?
·
¿Are
there any computer programming languages in which a word unit functions
as a command unit?
Specimens:
Instances of ‘argument-less’ ‘‘‘one word commands’’’ are quite
‘‘‘populous’’’ across many programming languages, e.g., the TI-Basic STOP command, END command, and
RETURN command, and the Oracle OLAP BREAK, CONTINUE, DO, DOEND, and ENDIF commands, respectively. The links below jump to documentation regarding those
commands, in the order just listed --
http://docs.oracle.com/cd/E12032_01/doc/epm.921/html_techref/calc/endif.htm
An online text by Mark A. Thomas, dated 2003, and entitled “Introduction
to Shell Programming”, describes a “shell script” that consists of a single
computer word, ‘hw’, that, when executed, generates the character-string ‘Hello
World!’. This command thus qualifies as inhering in
the category of “one-word commands”, among
other categories [see below] -- http://www.ucblueash.edu/thomas/Intro_Unix_Text/Shell_Prog.html [p. 2].
·
¿Are
there any computer programming languages in which a single qwi unit functions
as a command unit?
·
¿Are
there any computer programming languages in which a single qwy unit functions
as a command unit?
·
¿Are
there any computer programming languages in which a single qwyi unit functions
as a command unit?
Were we to find no instances
of such units presently in existence, then the “categories” qci, qcy, qcyi, qcw, qcwi, qcwy, and qcwyi, might all be instances of the generic “empty category”, ˜, and we might “assert” our solution as follows:
qci
= qcy
= qcyi
= qcw
= qcwi = qcwy = qcwyi = . [---) q0.
We might therefore write our full
solution for step s = 4 as --
)-|-(4 = i24 = i16 =
i
+ y + . + w + . + . + . + c + . + . + . + . + . + . + . + p =
i + y + w + c + p =
i + y + w + c + p =
bits + bytes + words
+ commands + programs.
But let’s keep all of our
‘categorial-combinatorially possible’
categories around for a while longer --
)-|-(4 = i24 = i16 =
i + y
+ qyi + w + qwi + qwy + qwyi + c + qci + qcy + qcyi + qcw + qcwi + qcwy + qcwyi + p.
Our categorial progression so
far can be summarized textually as below, and pictorially as follows that textual summary.
Textual Summary. The ‘Qualo-Fractal’
'content-structure' of this 'psychohistorical dialectic' to step 4 can be summarized
as follows --
Computer Programs “contain” Computer Commands, which “contain” Computer Words, which “contain” Computer Bytes, which “contain” Computer Bits.
Computer Programs “contain” Computer Commands, which “contain” Computer Words, which “contain” Computer Bytes, which “contain” Computer Bits.
The “four symbolic-elements
expression” for this model is thus i24 [four if we count the underscore under the i as a “symbolic-element”].
Pictorial Summary. The meaning mnemonically compressed into this four symbolic-element expression can be depicted as follows --
Stage 5. ¿What ‘category-descriptions’ do we
generate in our next step, step s = 5, that need
“solving-for” in terms of existing kinds of ‘modern computerware’ units, and
their categories?
With 5 as our step value, our Seldon Function calls our attention,
again, to the following 16 recurring
categories, plus to the following 16 ‘category-descriptions’ arising in this step for the
first time, thus yet to be “solved-for”:
)-|-(5 = i25 = i32 = ( i16 )2 =
(i + y
+ qyi + w + qwi + qwy + qwyi + c + qci + qcy + qcyi + qcw + qcwi + qcwy + qcwyi + p)2 =
i + y
+ qyi + w + qwi + qwy + qwyi + c + qci + qcy + qcyi + qcw + qcwi + qcwy + qcwyi + p +
qpi
+ qpy
+ qpyi + qpw
+ qpwi
+ qpwy
+ qpwyi
+ qpc
+ qpci
+ qpcy
+ qpcyi + qpcw
+ qpcwi
+
qpcwy
+ qpcwyi
+ qpp.
We do know how to “solve-for” qpp.
It describes a category for ‘programs
OF programs’
units -- a category each of whose units is a ‘program OF
programs’, i.e., each of which is a ‘meta-program’,
such that each typical such ‘meta-program’ is made up out of a heterogeneous multiplicity
of programs. Our experience of ‘modern computerware’
suggests that such units do indeed presently exist.
That category-description
describes the category of ‘multi-program’ units -- of computer “software systems” -- which we therefore symbolize, via the first letter of that name,
by s.
We may “assert” our solution
as follows: qpp = qs = s [---) q32.
Our step s = 5 equation-model, as we have solved it so far, thus now
looks like this --
)-|-(5 = i25 = i32 =
i + y
+ qyi + w + qwi + qwy + qwyi + c + qci + qcy + qcyi + qcw + qcwi + qcwy + qcwyi + p +
qpi
+ qpy
+ qpyi
+ qpw
+ qpwi + qpwy + qpwyi + qpc + qpci + qpcy + qpcyi
+ qpcw + qpcwi +
qpcwy + qpcwyi
+ s
-- since we have not yet determined
which actual categories of
the ‘modern computerware’ domain, if any,
are described by the ‘combinatorially’ possible,
algorithmically-generated 15 symbols --
qpi, qpy, qpyi, qpw, qpwi, qpwy, qpwyi, qpc, qpci, qpcy, qpcyi, qpcw, qpcwi, qpcwy, and qpcwyi.
But we do know how to
characterize the possible
categories that these 15 category-symbols “call for”, viz.:
·
qpi [---) q17 “calls for” the category of a kind of single bit
units that function as whole program units.
·
qpy [---) q18
“calls for” the category of a
kind of single byte units that function as program units.
·
qpyi [---) q19
“calls for” the category of a
kind of qyi units that
function as whole program units.
·
qpw [---) q20
“calls for” the category of a
kind of single word units that function as program units.
·
qpwi [---) q21
“calls for” the category of a
kind of qwi units that
function as whole program units.
·
qpwy [---) q22
“calls for” the category of a
kind of qwy units that
function as whole program units.
·
qpwyi [---) q23
“calls for” the category of a
kind of qwyi units
that function as whole program units.
·
qpc [---) q24
“calls for” the category of a
kind of single command units that function as program units.
·
qpci [---) q25 “calls for” the category of a kind of qci units that
function as whole program units.
·
qpcy [---) q26
“calls for” the category of a
kind of qcy units that
function as program units.
·
qpcyi [---) q27
“calls for” the category of a
kind of qcyi units
that function as whole program units.
·
qpcw [---) q28
“calls for” the category of a
kind of qcw units that
function as program units.
·
qpcwi [---) q29
“calls for” the category of a
kind of qcwi units
that function as whole program units.
·
qpcwy [---) q30
“calls for” the category of a
kind of qcwy units
that function as whole program units.
·
qpcwyi [---) q31
“calls for” the category of a
kind of qcwyi units
that function as whole units.
¿Do any such units presently exist, in the domain of
‘modern computerware’?
·
¿Are
there any computer systems in which a single bit unit functions as a program
unit?
·
¿Are
there any computer systems in which a single byte unit functions as a program
unit?
·
¿Are
there any computer systems in which a single qyi unit
functions as a program unit?
·
¿Are
there any computer systems in which a single word unit functions as a program
unit?
The online text by Mark A. Thomas, dated 2003, entitled “Introduction
to Shell Programming”, and already cited above, under the category of “one-word commands”, describes a
“shell script” that consists of a single computer word command, ‘hw’, that, when executed, generates the character-string
‘Hello World!’. This
command thus also qualifies as inhering in the category of “one-word programs”,
among other categories [see below] -- http://www.ucblueash.edu/thomas/Intro_Unix_Text/Shell_Prog.html [p. 2].
·
¿Are
there any computer systems in which a single qwi unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qwy unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qwyi unit
functions as a program unit?
·
¿Are
there any computer systems in which a single command unit functions as a
program unit?
The online text by Mark A. Thomas, dated 2003, entitled “Introduction
to Shell Programming”, and already cited above, under the category of “one-word commands”, and under the
category of “one-word programs”, describes
a “shell script” that consists of a single computer word/command, ‘hw’, that, when executed, generates the character-string
‘Hello World!’. This
command thus also qualifies as inhering in the category of “one-command programs”,
among other categories [see below] -- http://www.ucblueash.edu/thomas/Intro_Unix_Text/Shell_Prog.html [p. 2].
·
¿Are
there any computer systems in which a single qci unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qcy unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qcyi unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qcw unit
functions as a program unit?
The
online text by Mark A. Thomas, dated 2003, entitled “Introduction to Shell Programming”, and
already cited above, under the
category of “one-word commands”, under
the category of “one-word programs”, and
under the category of “one-command programs”, describes a
“shell script” that consists of a single computer word/command, ‘hw’, that, when
executed, prints-out the character-string ‘Hello World!’. This program/word/command thus also qualifies as inhering in the category of “one-word commands that are also whole programs
in themselves”, and the authors states, after describing this program: "You have now written your first successful shell program." --
·
¿Are
there any computer systems in which a single qcwi unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qcwy unit
functions as a program unit?
·
¿Are
there any computer systems in which a single qcwyi unit
functions as a program unit?
Were we to find no instances
of any such units, then the “categories” --
qpi, qpy, qpyi, qpw, qpwi, qpwy, qpwyi, qpc, qpci, qpcy, qpcyi, qpcw, qpcwi, qpcwy, and qpcwyi
-- might all be instances of
the generic “empty category”, . , and we may “assert” our solution as follows:
qpi = qpy = qpyi = qpw = qpwi = qpwy = qpwyi = qpc = qpci = qpcy = qpcyi = qpcw = qpcwi = qpcwy =
qpcwyi = . [---) q0.
qpcwyi = . [---) q0.
We might therefore write our full
solution for step s = 5 as --
)-|-(5 = i25 = i32 =
i
+ y + . + w + . + . + . + c + . + . + . + . + . + . + . + p +
. + ˜. + . + . + . + . + . + . + . + . + . + . + . + . + . + s =
i
+ y
+ w
+ c
+ p
+ s =
bits + bytes + words
+ commands + programs
+ software systems.
But let’s keep all of our
‘categorial-combinatorially possible’
categories around for a while longer, since we have already produced specimens of qci, qcy, qcw, qpc, and qpcw --
)-|-(5 = i25 = i32 =
i + y
+ qyi + w + qwi + qwy + qwyi + c + qci + qcy + qcyi + qcw + qcwi + qcwy + qcwyi + p +
qpi + qpy + qpyi + qpw + qpwi + qpwy + qpwyi + qpc + qpci + qpcy + qpcyi + qpcw + qpcwi +
qpcwy + qpcwyi + s.
A step s = 6 self-iteration would end with an ‘‘‘algebraic’’’
category-unknown described by the ‘category-description’ symbol qss [---) q64.
Because I believe that no
‘systems of systems’ -- no ‘software meta-systems’ ‘‘‘of the second degree’’’,
made up out of a heterogeneous multiplicity of software systems ‘‘‘of the first
degree’’’ -- are going to be familiar to many of my readers, if any, I’m
declaring presentation step s = 6 to be ‘‘‘non-present’’’, and terminating the narration of this model here, even
though some of the “cross product” category-descriptions, “crossing” category s with each of the thirty-one predecessor categories of
step s = 5, might turn out to have actualized meaning / not to have the value
‘full zero’, ..
Update: Since
the first version of this text was posted, there may, indeed, have come into
being at least one such “system of systems” with which a large number of Americans, at least,
have -- very recently -- become familiar:
www.Healthcare.gov .
On a recent episode of the PBS News
Hour [Episode 1015, original air date 23
October 2013], the vicissitudes of the irruption of this new scale
of qss ‘ideo-physio-ontology’, integrating systems and data
from multiple U.S. federal government agencies, from state governments, and
from private sector insurance companies, etc., were described in the following
terms:
“[Hari Sreenivasan of PBS]
Bill Curtis, there is a leak of Congressional testimony that’s planned for
tomorrow, and you already see the basis of fingerpointing from one contractor
to another.
What are the
challenges of pulling together 55 different contractors, and was the HHS in a
good position to lead them and pull them all together?
[Bill Curtis of Cast Software] Well,
the challenges are enormous, all that coordination, but they didn’t have enough
time to make it all happen and get it tested adequately.
They basically let the American people
do the testing.
So, they just
simply didn’t have enough time to pull off a system this big, and this complex,
in fact, it’s sort of wrong to say it’s a system; it’s actually a system of systems; we’re trying to integrate an awful lot of systems, as you just heard, from
a number of different sources, and that’s a huge integration
problem, and, in many cases, the government doesn’t have people that are used
to managing that level of complexity.”
[emphases added by M.D.] --
Our categorial progression so
far can be summarized textually as below, and pictorially as follows that textual summary.
Textual Summary. The ‘qualo-fractal’
content-structure of this psychohistorical dialectic to step 5 can be summarized as follows --
Computer Software Systems “contain” Computer Programs, which “contain” Computer Commands, which “contain” Computer Words, which “contain” Computer Bytes, which “contain” Computer Bits.
Computer Software Systems “contain” Computer Programs, which “contain” Computer Commands, which “contain” Computer Words, which “contain” Computer Bytes, which “contain” Computer Bits.
The “four symbolic-elements
expression” for this model is thus i25 [four if we count the underscore under the i as a “symbolic-element”].
No comments:
Post a Comment