Parent

ABSTRACT : Never forgetting Kant`s emphasis on the ' ding an sich ' , what are the most generic , lowest level objects upon which to found a language from the silicon up ? Is it possible to construct a system whose only fixed datum in
its address space |(| i N | for some N > 0 |)| is a pointer in location 0 ?

 
 To quote from  CoSy/Language/Ultimate  : 
 
 Alan Kay , the father of object-oriented SmallTalk , made the comment at a
 poorly attended invited address at ( if memory serves ) the APL81 confrence
 in Rochester  that APL was the first object-oriented language - it is just
 that it only had one type of object , the ' array ' , and no vocabulary for
 creating others .. . What this misses is that the idea of an array is
 pervasive . It is the geometric aspect of the organization of finite
 collections .
 An address space is a vector , i N , for as large as possible
 N , where ' i ' is the index generator , e.g. |(|  i 4  |>|  0 1 2 3  |)| .
 
 
 Like the insights of APL , which have still not been appreciated by the
 general computing community , the notion of objects in programming is
 decades old . SmallTalk in the `70s was an elegant distillation of this
 cluster of concepts  relative to which C++ is a distressing regression .
 Java finally recognizes that to truly have objects , the system must
 automatically manage their mapping to memory address space - which is the
 object in which any of these abstractions must be reified .
 I summarize Java as having brought the mainstream community up to where
 APL was in the mid `70s .

 DING AN SICH
 One of Immanual Kant`s big ideas was  to not get hung up on the labels
  attached to things , but try to see thru to the ' thing in itself '
  -- sort of the  blindpersons groping an elephant  situation .
 What is the below :

     \BobArmstrong;212.285.1864 X:-732-0244 bob@cosy.com ;Coherent Systems,
      Inc/ 42 Peck Slip 4b/ New York NY 10038.1725 ;

 Nowdays , We live in  HyperTextMarkupLanguage  string , and the above  String
 may be referenced by something like , in my mental ulinga :

  |(| String is -1 pik ( '</B>' '<B>' ) WITHIN  TEXT ABOVE HERE . |)| .

 At this point , we and our machine are talking about the same String .
 I also see it as what I call a Notebook_Format_Address_Entry .
  I have some verbs to convert whole catinated strings of these to
   mailing labels , etc , but have never implemented any input or editing
   cover functions .
  They are after all , while forming highly parsable heirarchical
   data base records , if you will ,  just  TEXT  .
  I can dive in and edit it as such .

 The objects that a verb acts on are its domain . The intersections of
 domains of composed functions delimit subclasses .

 The ding an sic is glimpsed by the results of the set of verbs which
 can be applied to it . 
  ( See : Reality Rules : " Picturing the World in Mathematics : The
  Fundamentals " by John L. Casti for a for formal treatment . ) 

 THE GENERIC OBJECT : 
 On the machine side , we live in address spaces - strings of memory cells .

  On our interface , we live in HTML - strings of characters .

 So the generic object is strings of things .
  ( Feel like a Turing machine ? )

  A specially important type ( == class ) of strings is strings of addresses
  of strings .

  A class that is totally defined by the action applied to it is
  ExecutionStrings . If the processor ( == interpreter ) aims its
  ExecutionPointer ( == ProgramCounter ) at an address , the contents better
  be the start of an executable ( == interpretable ) string .

  Forth chips have combined these classes by using the most significant bit
  in execution strings to gate whether the remainder of the cell is an
  instruction for the processor , xor the address of the head of a string to
  execute . If it is a processor instruction , another bit determines whether
  , upon completion , to simply increment the ExecutionPointer , or return to
  the next cell in the calling string .  ( Notice twice the memory is
   available for @ ( == fetch ) and ! ( == store ) as for execution . ) 

 This use of the head of a string , in this case the high order bit of the
 0th cell of the string , as a symbol of the type of the remainer , strikes
  me as a real good idea .
 The bits ( = subspaces ) of that head cell are prime real estate .
 At this point , we have something beyond the Ding_an_Sic , The Thing has a
  label .
 It`s type , its class , is |(| Type : Class : { head String } |)| .
  An intriguing notion is to to have the Type be the address of the execution
  string handling the type .

 Seems to me a good idea to put the number of cells of the string in the
  next cell , if there is a next cell ( the type of the head may define
  itself as a singleton . For instance , the NIL symbol is complete in
  itself ) .
 On this issue , there is convergence with the m-entry described by
  BobBernecky as the traditional APL memory item structure in his
  comp.lang.apl posting :  Language/APL_Inside 
  One difference , I want structures that are independent of their location
  relative to anything else . Therefore , I don`t want to mix memory
  management things like backpointers in the object itself .

 Alan Graham in his presentation  NY/SigAPL:0 
  lists as a core idea , that there are only 2 data structures :
   Atoms  and  Collections .
 In the context here , that might be said :
   Atoms  and  Strings of addresses of Strings
  , i.e. : Strings of pointers , i.e. : vectors of vectors  .
 This is truly the generic structure whose manipulation ought be optimized .

 Note that the APLish vocabulary of , e.g. : take , drop , each , pick ,
  etc ; , applies to all conceptual levels of the strings we have discussed .


 The answer to the question in the Abstract ? 
 The Forth chips described above embody the answer . If the leading bit
  |(|  head  bool  head AddressSpace  |)|
    where  ` bool  ( like  #:  in  J ) converts the view ( = type ) of
    its argument to boolean .  |)|
 is TRUE ( == 1 ) , the rest of the sel is the beginning of an execution
 string which must know more about the layout of the space .

                            | DDT   |>| SAT.JAN,980124,17:29-5      |
 End of version submitted for printing in ToT proceedings . Modifications
 entered in  COLOR= "#8F008F" 
 |(| DDT |>| MON.JAN,980126,12:45-5  |)|
 NEXT : 
 Pointer vector

 SymbolTable


 Ultimate object :  NameSpace .