• CoSy Homes
  • K.CoSy
  • CoSy/Life
  • CoSy/Current
  • ?Wha?
  •  CoSy Comment Comments cursor hover comments
  • Feedback
    © Bob Armstrong
    /(/ tue.apr.20020430.000940 /)/
  • /CoSy­/language­/lowdown
    Search CoSy
         by FreeFind
    Site Map What's New
    powered by FreeFind

    Low Down Objects

    Presented @
    NY/SIGAPL : APLToT98 "APL as a Tool of Thought" #10 .
    Stevens Institute , Hoboken, NJ , SAT,980131


      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 ?
    It`s simplest now days to just clik to see where I`m coming from and heading . If you don`t have a computer yourself , every public library should have browsers by now . See particularly CoSy/Language/Booleans and CoSy/Language/Booleans971222 discussions from comp.lang.apl and comp.lang.forth . And , of course , This page , .
     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 .


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


    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 .
    See also : Language/APL_Inside comp.lang.apl posting by BobBernecky about the internal structure of APL .
                                | 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 .

    Rapid Quantitive Modeling
    & a whole lot more
    CoSy Homes
    Constructing affordable homes
    in the Boroughs of New York City
    Contact : Bob Armstrong ; About this page : ; 212.285.1864
    Coherent Systems / 42 Peck Slip 4b/ New York NY 10038.1725
    Note : I reserve the right to post all communications I receive or generate to CoSy website for further reflection .
    /\ /\ Top /\ /\ ;