Part III. B.: Interlude. The Dialectic of 'Modern Computerware'. The F.E.D. Psychohistorical-Dialectical 'Meta-Equation' of Human-Social Formation(s) 'Meta-Evolution'.

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 second example ‘systematic-dialectical meta-model’ is a bit more challenging than the ‘systematic-dialectical meta-model’ of “TV-Series”, presented earlier in this series, but only because it requires some “domain-expertise” -- or, at least, a small degree of “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’ ‘dialectical meta-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 step-wise ‘meta-equation meta-model’ that we will build will generate symbolizations of these categories in that strict, systematic order of rising complexity.

Unlike the main, ‘[psycho]historical dialectic of human social formation(s) meta-model’ of this series, this will be a “snapshot” ‘meta-model’, a “synchronic” ‘meta-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 all presently exist, or that might possibly presently exist, for the meta-model’s domain, in their systematic order, as described above.

Again, our ‘meta-model’ here will not be a “chronology” ‘meta-model’, or “diachronic” ‘meta-model’, like the partly previously-presented, major ‘meta-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 ‘meta-model’ of a ‘self-advancing’ historical progression of ontology, with each historical epoch containing both old ontology, inherited from past historical epochs, and persisting into the present, 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 ‘meta-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.

Enjoy!


Regards,

Miguel

 



To get started, we must determine the starting-point -- the point-of-departure -- for our systematic ‘meta-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, by ‘connotational entailment’.

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 ‘meta-model’, via the second letter of that name, as i, or as q_i, identifying that specific category with the generic first category symbol of our generic category-arithmetic ‘meta-model’, namely, the symbol q₁, in an identification, “interpretation”, or “assignment” [ ‘[---)’ ] that we indicate by writing -- 

 i  =  q_i  [---)  q₁.

Our ‘meta-model’ then, will be a ‘meta-equation’, that looks like this --

)-|-(_s   =   i^2s   =   bits^2s    

-- with the ‘pure-quantifier’ Whole number variable s indicating the step in our systematic presentation that the ‘accumulation of categories’, denoted by )-|-(_s, represents.  


This ‘meta-model meta-equation’ is made up out of a heterogeneous multiplicity of qualitatively, ontologically different model equations -- a qualitatively, ontologically different model equation for each distinct value of the step parameter, s.

Stage 0.  Our initial step -- step s = 0 -- contains only our starting category, i = q_i --

)-|-(₀   =   i²⁰   =   i¹   =   i

[Note:  i¹ generates 1 category-[symbol]]

because 2 “raised” to the power 0 -- 2⁰ -- 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 ‘meta-equation meta-model’ gives us something initially “unknown” -- and, therefore, something ‘‘‘algebraical’’’, not just ‘‘‘arithmetical’’’:  

 something to “solve-for” --

)-|-(₁   =   i²¹   =   i²   =   i  x  i    =   q_i x q_i   =    


q_i   +  q_ii   =   


i   +  q_ii

[Note emerging pattern:  i¹ generates 1 category, i², 2 categories]

-- because 2 “raised” to the power 1 -- 2¹ -- is just 2, and because our rule for multiplying a generic category, call it q_x  =  x, “by”, or “into”, itself, is, simply --  


q_x x q_x   =   q_x   +  q_xx   =   x  + q_xx.

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 q_ii, means?

Well, the generic rule to “solve-for” the categorial meaning of such symbols is that, if we already know what is meant by category q_x  =  x, then the symbol q_xx describes a category each of whose units is an <<aufheben>> ‘x OF xs’, that is, a category for a qualitatively different kind of units, called ‘meta-xs’, each single such ‘meta-x’ unit being made up out of a multiplicity of xs , i.e., of x units.

To be specific with this rule, q_ii specifies a category each of whose units is a ‘bit OF bits’, that is, an <<aufheben>> ‘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 already, 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:  q_ii  |-.=  q_y  =  y  [---)  q₂.

That is, by means of the expression above, we assert that the formerly unknown, algebraic value, q_ii, has now been determined, or solved, as having the known categorial-value, i.e., the meaning-value, or interpretation-value -- the ‘connotative determination’ -- y, corresponding to the “uninterpreted”, generic dialectical-arithmetic, meta-number value q₂.

Again, what is dialectical about the relationship between i and  i², or  i x i, or ii, or i of i, or i(i), the relationship of what we call ‘meta-unit-ization’, meta-«monad»-ization’, or  ‘meta-holon-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-model of our ‘multi-step meta-equation meta-model’ is --

)-|-(₁   =   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 consecutively  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 --

)-|-(₂   =   i²²   =   i⁴   =  ( i² )²   =  ( i   +  y )²   =    

( i   +  y ) x ( i   +  y )    =    

i   +  y   +  q_yi  +  q_yy.

This result arises by way of two key rules of Seldonian 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.  q_b x q_a   =   q_a   +  q_ba   =   a   +  q_ba;  

      special case:  q_b x q_b   =   q_b  +  q_bb   =   b  +  q_bb.

2.  q_a + q_a   =   q_a; 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.  Hence this “purely”-qualitative algebra is ‘unquantifiable’, or at least, no categorial ‘qualifier’, q_a, can persist in any “quantity” greater than unity, 1.

3.  There is no q_x, within the space of the Seldonian categorial ‘meta-numbers’, such that --  

q_a + q_b   =   q_x

-- i.e.,  different categories, added together [as opposed to being ‘‘‘multiplied’’’ [together]], do not reduce, or “amalgamate”, [in]to a single category, as in the proverbial ‘apples + oranges’, or a + o.

Well, we already know how to “solve-for” q_yy. 

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 already, 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:  q_yy  |-.=  q_w  =  w  [---)  q₄.

Our step s = 2 equation-model, as we have solved it so far, thus now looks like this --

)-|-(₂   =   i²²   =   i⁴   =   i  +  y  +  q_yi  +  w   

[Note emerging pattern:  i² generates 2 categories, i⁴, 4 categories]

-- since we still have not yet determined which actual category of the ‘modern computerware’ domain is described by the algorithmically-generated symbol q_yi -- if any, i.e., if q_yi 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  +  q_yi

-- generically speaking, the categorial relationship to be called to the user’s attention by this operation, in this ‘categorial algebra’, is, again, a synchronic «aufheben» relationship, but this time between i and q_yi.   


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, q_yi, 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 q_WL 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 q_yi 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 --

http://docs.lib.purdue.edu/lars_symp/459

-- which 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 absence of a particular attibute.  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 bitplane 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” q_yi might be a specific 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 -- 


q₃ (---]  q_yi   =  .  [---)  q₀.

We might therefore write our full solution for step s = 2 as --

)-|-(₂   =   i²²   =   i⁴   =   


i  +  y  +  q_y  +  w   =   

i  +  y  +  .  +  w   =   i  +  y  +  w   =   

bits  +  bytes  +  words.

But let’s keep our ‘categorial-combinatorially possible’ category q_yi around, since I believe that we have found a specimen of just such an entity in our research, just summarized above --

)-|-(₂   =   i²²   =   i⁴   =   i  +  y  +  q_yi  +  w.

Stage 3.  ¿What ‘category-specs.’ do we generate in our next step, step s = 3, that need “solving-for”? 

Let’s see:

)-|-(₃   =   i²³   =   i⁸   =  ( i⁴ )²   =    

(i   +   y   +  q_yi  +  w) x (i   +   y   +  q_yi  +  w)    =    

i   +  y   +  q_yi  +  w   +  q_wi   +  q_wy   +  q_wyi   +  q_ww.

We know -- from past experience, narrated above -- how to “solve-for” q_ww. 

The algebraic symbol-description q_ww 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’ unit is made up out of a multiplicity of at least two word units.   

Our experience of ‘modern computerware’ suggests that such units do indeed already, presently exist.

The q_ww ‘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:  q_ww  |-.=   q_c  =  c  [---)  q₈.

Our step s = 3 equation-model, as we have solved it so far, thus now looks like this --

)-|-(₃   =   i²³   =   i⁸   =  


i   +  y   +  q_yi  +  w   +  q_wi   +  q_wy   +  q_wyi   +  c   


[Note:  i⁸ 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 q_wi, q_wy, and q_wyi, if any.

But we already know how to characterize the possible categories that these 3 category-symbols “call for”, viz. --

·  q_wi   [---)  q₅ “calls for” the category of a kind of bit units that stand in for computer word units.

·   q_wy  [---)  q₆ “calls for” the category of a kind of byte units that stand in for computer word units.

·   q_wyi [---)  q₇ “calls for” the category of a kind of q_yi 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 unit? 

      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 unit?

       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 q_yi unit can function as a whole word unit?

 

Were we to find no instances of such units in present existence, then the “categories” q_wi, q_wy, and q_wyi might all be specific instances of the generic “empty category”, ˜, and we might “assert” our solution as follows -- 

q_wi  =  q_wy  =  q_wyi  =  ˜  [---)  q₀.

We might therefore write our full solution for step s = 3 as --

)-|-(₃   =  i²³   =   i⁸   =   


i   +  y   +  q_yi  +  w   +  q_wi   +  q_wy   +  q_wyi   +  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 q_wi and q_wy in contemporaneous existence / ‘extantcy’ --

)-|-(₃   =   i²³   =   i⁸   =   


i  +  y  +  q_yi  +  w  +  q_wi   +  q_wy   +  q_wyi   +  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’:

)-|-(₄   =   i²⁴   =   i¹⁶   =  ( i⁸ )²   =   

(i  +  y  +  q_yi  +  w  +  q_wi  + q_wy  + q_wyi  + c)²    =    

i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c +  

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + q_cc.

We already know how to “solve-for” q_cc. 

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’ unit is made up out of a multiplicity of command units.   

Our experience of ‘modern computerware’ suggests that such units do indeed already, presently exist.

That category-description describes the category of ‘multi-command’ units -- i.e., of computer “programs” -- which we therefore symbolize, via the first letter of its name, by p.

We may “assert” [‘|-.’] our solution as follows:  q_cc  |-.=  q_p  =  p  [---)  q₁₆.

Our step s = 4 equation-model, as we have solved it so far, thus now looks like this --

)-|-(₄   =   i²⁴   =   i¹⁶   = 

i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c + 

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + p

-- since we have not determined which actual categories of the ‘modern computerware’ domain, if any, answer to the ‘combinatorially’ possible, mechanically-generated symbols q_ci, q_cy, q_cyi, q_cw, q_cwi, q_cwy, and q_cwyi.   


But we do know how to characterize the possible categories that these seven category-symbols “call for”, viz.:

·   q_ci [---)  q₉ “calls for” the category of a kind of single bit units that function as command units.

·   q_cy [---)  q₁₀ “calls for” the category of a kind of single byte units that function as command units.

·   q_cyi [---)  q₁₁ “calls for” the category of a kind of q_yi units that function as command units.

·    q_cw [---)  q₁₂ “calls for” the category of a kind of single word units that function as command units.

·    q_cwi [---)  q₁₃ “calls for” the category of a kind of q_wi units that function as command units.

·    q_cwy [---)  q₁₄ “calls for” the category of a kind of q_wy units that function as command units.

·    q_cwyi [---)  q₁₅ “calls for” the category of a kind of q_wyi 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 changed, 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 computer programming languages in which a single q_yi unit functions as a command unit?

·         ¿Are there 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://tibasicdev.wikidot.com/stop

                  http://tibasicdev.wikidot.com/end

                  http://tibasicdev.wikidot.com/return

                  http://docs.oracle.com/cd/B10501_01/server.920/a90842/ch13.htm#1007304

                  http://docs.oracle.com/cd/B28359_01/appdev.111/b28370/continue_statement.htm

                  http://docs.oracle.com/cd/B28359_01/olap.111/b28126/dml_commands_1034.htm

                  http://docs.oracle.com/cd/B28359_01/olap.111/b28126/dml_commands_1034.htm

                  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 computer programming languages in which a single q_wi unit functions as a command unit?

·         ¿Are there computer programming languages in which a single q_wy unit functions as a command unit?

·         ¿Are there computer programming languages in which a single q_wyi unit functions as a command unit?

Were we to find no instances of such units presently in existence, then the categories q_ci, q_cy, q_cyi, q_cw, q_cwi, q_cwy, and q_cwyi, might all be instances of the generic “empty category”, ˜, and we might “assert” [‘|-.’] our solution as follows --

q_ci = q_cy = q_cyi = q_cw = q_cwi = q_cwy = q_cwyi    |-.=    ˜ [---)  q₀.

We might therefore write our full solution for step s = 4 as --

)-|-(₄   =   i²⁴   =   i¹⁶   = 

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

)-|-(₄   =   i²⁴   =   i¹⁶   = 

i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c + 

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + p.

If we retain specific representation for all of these ‘categorial-combinatorially possible’ categories’ category-symbols, i.e., including the “merely hybrid”, ‘‘‘dialectical synthesis’’’, ‘‘‘complex unity’’’, ‘‘‘exceptions/anomalies’’’ category-symbols, then our step s = 4 categorial cumulum becomes --

bits  +  

 bytes  + units which are both/neither bytes &/NOR bits  +   

words  +  units which are both/neither words &/NOR bits  + 
units which are both/neither words &/NOR bytes  +
units which are both/neither words &/NOR bytes &/NOR bits  +
 
commands  +  units which are both/neither commands &/NOR bits  +
units which are both/neither commands &/NOR bytes   +
units which are both/neither commands &/NOR bytes &/NOR bits  +
units which are both/neither commands &/NOR words  +
units which are both/neither commands &/NOR words &/NOR bits  +
units which are both/neither commands &/NOR words &/NOR bytes  +
units which are both/neither commands &/NOR words &/NOR bytes &/NOR bits  +
 
programs.

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.

The “four symbolic-elements expression” for this ‘meta-model’ is thus i²⁴ [four if we count the underscore under the i as a separate “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, and which thus are yet to be “solved-for”:

)-|-(₅   =   i²⁵   =   i³²   =  ( i¹⁶ )²   =  

(i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c  +  

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + p)²    =    

i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c + 

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + p +

q_pi + q_py + q_pyi + q_pw + q_pwi + q_pwy + q_pwyi +  

q_pc + q_pci + q_pcy + q_pcyi + q_pcw + q_pcwi +

q_pcwy + q_pcwyi + q_pp.

We do know how to “solve-for” q_pp. 

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 already, 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:  q_pp  |-.=  q_s  =  s  [---)  q₃₂.

Our step s = 5 equation-model, as we have solved it so far, thus now looks like this --

)-|-(₅   =   i²⁵   =   i³²   = 

i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c +  

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + p +

q_pi + q_py + q_pyi + q_pw + q_pwi + q_pwy + q_pwyi +  

q_pc + q_pci + q_pcy + q_pcyi + q_pcw + q_pcwi +  q_pcwy + q_pcwyi + 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 --

 q_pi, q_py, q_pyi, q_pw, q_pwi, q_pwy, q_pwyi, q_pc, q_pci, q_pcy, q_pcyi, q_pcw, q_pcwi, q_pcwy, & q_pcwyi.

But we do know how to characterize the possible categories that these 15 category-symbols “call for”, viz.:

·  q_pi [---) q₁₇ “calls for” a sub-category of single bit units that function as whole program units.

·   q_py [---)  q₁₈ “calls for” a sub-category of single byte units functioning as whole program units.

·   q_pyi [---) q₁₉ “calls for” the category of a kind of q_yi units that function as whole program units.

·   q_pw  [---)  q₂₀ “calls for” the category of a kind of single word units that function as program units.

·   q_pwi [---)  q₂₁ “calls for” the category of a kind of q_wi units that function as whole program units.

·    q_pwy [---)  q₂₂ “calls for” the category of a kind of q_wy units that function as whole program units.

·    q_pwyi [---)  q₂₃ “calls for” the category of a kind of q_wyi units functioning as whole program units.

·    q_pc [---)  q₂₄ “calls for” a sub-category of single command units functioning as program units.

·    q_pci [---)  q₂₅ “calls for” the category of a kind of q_ci units that function as whole program units.

·    q_pcy [---)  q₂₆ “calls for” the category of a kind of q_cy units that function as program units.

·    q_pcyi [---)  q₂₇ “calls for” the category of a kind of q_cyi units functioning as whole program units.

·    q_pcw [---)  q₂₈ “calls for” the category of a kind of q_cw units that function as program units.

·    q_pcwi [---)  q₂₉ “calls for” the category of a kind of q_cwi units that function as whole program units.

·    q_pcwy [---)  q₃₀ “calls for” the category of a kind of q_cwy units functioning as whole program units.

·    q_pcwyi [---)  q₃₁ “calls for” a sub-category of q_cwyi units functioning as whole program 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 q_yi 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 q_wi unit functions as a program unit?

·         ¿Are there any computer systems in which a single q_wy unit functions as a program unit?

·         ¿Are there any computer systems in which a single q_wyi 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 q_ci unit functions as a program unit?
 

·         ¿Are there any computer systems in which a single q_cy unit functions as a program unit?

·         ¿Are there any computer systems in which a single q_cyi unit functions as a program unit?
 

·         ¿Are there any computer systems in which a single q_cw 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." --   

      http://www.ucblueash.edu/thomas/Intro_Unix_Text/Shell_Prog.html [p. 2, emphasis added by M.D.].

·         ¿Are there any computer systems in which a single q_cwi unit functions as a program unit?

·         ¿Are there any computer systems in which a single q_cwy unit functions as a program unit?

·         ¿Are there any computer systems in which a single q_cwyi unit functions as a program unit?

Were we to find no instances of any such units, then the “categories” --

q_pi, q_py, q_pyi, q_pw, q_pwi, q_pwy, q_pwyi, q_pc, q_pci, q_pcy, q_pcyi, q_pcw, q_pcwi, q_pcwy, & q_pcwyi 

-- might all be instances of the generic “empty category”, ˜, and we may “assert” [‘|-.’] our solution as follows -- 

|-.  q_pi = q_py = q_pyi = q_pw = q_pwi = q_pwy = q_pwyi =  

q_pc = q_pci = q_pcy = q_pcyi = q_pcw = q_pcwi = q_pcwy = 
q_pcwyi   |-.=   ˜ [---)  q₀.

We might therefore write our full solution for step s = 5 as --

)-|-(₅   =   i²⁵   =   i³²   = 

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

)-|-(₅   =   i²⁵   =   i³²   = 

i  + y  + q_yi + w  + q_wi + q_wy + q_wyi + c +  

q_ci + q_cy + q_cyi + q_cw + q_cwi + q_cwy + q_cwyi + p +

q_pi + q_py + q_pyi + q_pw + q_pwi + q_pwy + q_pwyi +  

q_pc + q_pci + q_pcy + q_pcyi + q_pcw + q_pcwi +  q_pcwy + q_pcwyi + s.

A step s = 6 self-iteration would end with an ‘‘‘algebraic’’’ category-unknown described by the ‘category-description’ symbol q_ss [---)  q₆₄.

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 ‘meta-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 q_ss ‘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.] --

http://www.pbs.org/newshour/bb/government_programs/july-dec13/healthcare2_10-23.html

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, naming only its ‘self-hybrid’ categories, and excluding any mention of the many possible ‘‘‘merely-hybrid’’’, ‘‘‘exception’’’, ‘‘‘anomaly’’’, ‘‘‘paradoxical’’’, ‘‘‘dialectical synthesis’’’, or ‘‘‘complex unity’’’ categories, 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.

The “four symbolic-elements expression” for this ‘meta-model’ is thus i²⁵ [four if we count the underscore under the i as a separate “symbolic-element” in its own right].