Tuesday, April 29, 2014

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 IIIB.:   InterludeThe Dialectic of 'Modern Computerware'.



The Systematic Dialectic of 'Modern Computerware' --
 
Systematically Presented via a 4-Symbol Expression.







Dear Readers,


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 “synchronicmeta-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 “diachronicmeta-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 qi, identifying that specific category with the generic first category symbol of our generic category-arithmetic meta-model, namely, the symbol q1, in an identification, “interpretation”, or “assignment” [ [---)’ ] that we indicate by writing -- 

 i  =  qi  [---)  q1.



Our meta-modelthen, will be a meta-equation, that looks like this --

)-|-(s   =   i2s   =   bits2s    

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

)-|-(0   =   i20   =   i1   =   i

[Note:  i1 generates 1 category-[symbol]]

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

[Note emerging pattern:  i1 generates 1 category, i2, 2 categories]

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


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 already know what is meant by category qx  =  x, then the symbol qxx 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-xunit being made up out of a multiplicity of xs , i.e., of x units.

To be specific with this rule, qii 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:  qii  |-.=  qy  =  y  [---)  q2.

That is, by means of the expression above, we assert that the formerly unknown, algebraic value, qii, 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 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, 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 --

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

)-|-(2   =   i22   =   i4   =  ( i2 )2   =  ( i   +  y )2   =    

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

i   +  y   +  qyi  +  qyy.


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.  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.  Hence this purely-qualitative algebra is unquantifiable’, or at least, no categorial qualifier’, qa, can persist in any quantity greater than unity, 1.

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

qa + qb   =   qx

-- 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” 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 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:  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]

-- 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 algebra’, is, again, a synchronic «aufheben» relationship, but 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”.



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


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


q3 (---]  qyi   =  .  [---)  q0.



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

)-|-(2   =   i22   =   i4   =   


i  +  y  qy  +  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 of 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. 


The algebraic symbol-description qww 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-wordunit 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 qww ‘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]

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

 

Were we to find no instances of such units in present existence, then the “categories” qwi, qwy, and qwyi might all be specific 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  =   

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

)-|-(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 already 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’ 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:  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.:

·   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 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 TECOText 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 qyi 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/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-stringHello 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 qwi unit functions as a command unit?

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

·         ¿Are there 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   =   

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.



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-Fractalcontent-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 i24 [four if we count the underscore under the i as a separate “symbolic-element”].




Pictorial SummaryThe 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”:



)-|-(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 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:  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, & qpcwyi.





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

·  qpi [---) q17 “calls for” a sub-category of single bit units that function as whole program units.

·   qpy [---)  q18 “calls for” a sub-category of single byte units functioning as whole 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 functioning as whole program units.

·    qpc [---)  q24 “calls for” a sub-category of single command units functioning 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 functioning 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 functioning as whole program units.

·    qpcwyi [---)  q31 “calls for” a sub-category of qcwyi 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 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." --   

      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 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, & 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.





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 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 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, its sort of wrong to say its a system; its actually a system of systems; were 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, 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 i25 [four if we count the underscore under the i as a separate “symbolic-element” in its own right].










 

No comments:

Post a Comment