QuoteRef: cbb_1973 ;;Algol handles literal constants by calling the appropriate runtime conversion routine

QuoteRef: cbb_1973 ;;cobol (ICT Rapidwrite) lets programmers use short forms which are then expanded (fill in the blanks)

QuoteRef: cbb_1973 ;;formac FORMAC formula manipulator : replace, substitute, expand, search equivalent

QuoteRef: cbb_1973 ;;Jovial packing structures both in series and in parallel eg 123123 or 112233 where "123" is the unit

QuoteRef: cbb_1973 ;;PL/N a,b,c = 0

QuoteRef: cbb_1973 ;;pl/n has an alphabetic manual

QuoteRef: cbb_1973 ;; pl/n do case i; statement-list the i'th statement is executed

QuoteRef: cbb_1973 ;;PL/1: (3)"abc" == "abcabcabc"

QuoteRef: cbb_1973 ;; [expansion capabilities of PL/1 and Algol very seldom used, i.e. power v. access

QuoteRef: cbb_1973 ;;[reading (QuoteRef: dahlOJ_1972) array is a form of a record

QuoteRef: cbb_1973 ;;[reading (QuoteRef: elcoEW_1971) programming generally involves putting together and using a unique package not writing an algorithm

QuoteRef: cbb_1973 ;;[reading (QuoteRef: goodJB2_1976) want a way to write programs as tightly interconnected representation same as assembly language

QuoteRef: cbb_1973 ;;[reading (QuoteRef: grieD_1971) in Lang the terminals are machine instructions

QuoteRef: cbb_1973 ;;[reading (QuoteRef: halpMI1_1968) my operator literals are "modal" commands to the processor is the same way that $LIST is a modal command to an assembler. i.e. there is no separation between base language commands and processor commands

QuoteRef: cbb_1973 ;;[reading (QuoteRef: mckeWM_1974) info queues-- create, destroy ,send, receive, conditional receive and send with and receive with interrupt (send and tell someone)

QuoteRef: cbb_1973 ;;Quote: the central idea of Thesa is abstraction, i.e., the ability to refer to anything by name

QuoteRef: cbb_1973 ;;[reading (QuoteRef: sammJE5_1962) making syntactic definition the norm instead of the exception

QuoteRef: cbb_1973 ;;[reading (QuoteRef: sammJE_1969) precedence by spatial grouping eg a*b + c*d or d* b+c

QuoteRef: cbb_1973 ;;[reading (QuoteRef: shawCJ_1963) entry descriptor describes a pattern eg integer-class + integer-class

QuoteRef: cbb_1973 ;;[reading (QuoteRef: snowRA_1973) Pearl is similar to Purna, uses "machines" instead of objects for defined entities

QuoteRef: cbb_1973 ;;[reading (QuoteRef: wirtN5_1967) don't want to specify more info than one has eg solitaire game

QuoteRef: cbb_1973 ;;(lost) continuous to objects is seeing boundaries

QuoteRef: cbb_1973 ;; entry is something that is complicated, understood through another object

QuoteRef: cbb_1973 ;;flow charting does not show structure--is purely goto i.e., actually step back

QuoteRef: cbb_1973 ;;10/2/73 not a compiler that makes good code from bad sources, but one that makes it difficult to write a bad source

QuoteRef: cbb_1973 ;;10/2/73 need new way to write programs-- they force line, is keeping bad part about computers

QuoteRef: cbb_1973 ;;11/3/73 Have all labels unique

QuoteRef: cbb_1973 ;;11/3/73 Have sets and lists (control vectors). Are dual or complementary forms is one ordered info and other unordered info

QuoteRef: cbb_1973 ;;11/27/73 want way to expand in line instead of as a procedure

QuoteRef: cbb_1973 ;;11/27/73 INCLUDE is an elementary text macro

QuoteRef: cbb_1973 ;;11/30/73 want a language which is locally definable (i.e. continuous) but no where differentiable

QuoteRef: cbb_1973 ;;11/30/73 1 can be either a symbol or a value

QuoteRef: cbb_1973 ;;1/12/74 infoqueues deal with information (delivered particularly) while events deal with presence (delivered globally)

QuoteRef: cbb_1973 ;;1/12/74 Information queuing want allocated storage, provide an endzone where only queue heads can go, means information is always there if it is available, basically gives two completely different modes of operation

QuoteRef: cbb_1973 ;;1/29/74 idea- flesh it out (static)--build it (dynamic, design) -- run it

QuoteRef: cbb_1973 ;;1/29/74 assembly language is more of a process, only as follow its paths do you see how it behaves

QuoteRef: cbb_1973 ;;1/29/74 want a way to put an idea into space, give it flesh and bones

QuoteRef: cbb_1973 ;;2/2/74 done--successfully done this field and returning to control point

QuoteRef: cbb_1973 ;;2/3/74 i.e. something outside the control point decides which branch to take

QuoteRef: cbb_1973 ;;2/3/74 it isn't the compiler that produces code but the program itself, just as it isn't the pen and pencil that produce the program

QuoteRef: cbb_1973 ;;2/17/74 a program is a threaded tree a static representation of a dynamic process

QuoteRef: cbb_1973 ;;2/17/74 File's are timer related and maps are space oriented

QuoteRef: cbb_1973 ;;2/23/74 a.b.c\c is changing the reference point of a map i.e., letting the map cover a large area but remain local

QuoteRef: cbb_1973 ;;2/23/74 a.b.c\c is changing the reference point of a map i.e., letting the map cover a large area but remain local

QuoteRef: cbb_1973 ;;2/27/74 inverse eg arcsine (sin()) makes debugging much easier

QuoteRef: cbb_1973 ;;2/28/74 Now any space can locally be described as a map (i.e. == any space is locally a vector space)

QuoteRef: cbb_1973 ;;2/28/74 Maps consist of reference points and reference directions and reference lengths

QuoteRef: cbb_1973 ;;2/28/74 Now any space can locally be described as a map (i.e., == any space is locally a vector space)

QuoteRef: cbb_1973 ;;3/3/74 discontinuity is the way to represent a finite multi-dimensional space in a single dimension

QuoteRef: cbb_1973 ;;3/3/74 interrupts are always a change of state with the ability to restore the previous state

QuoteRef: cbb_1973 ;;3/3/74 Both maps and files are ways to take a multi-dimension into one dimension i.e., maps for space and files for process

QuoteRef: cbb_1973 ;;3/4/74 finding a next element in a file generates an interrupt to return to caller; reduction is execution on get an interrupt

QuoteRef: cbb_1973 ;;3/4/74 all operations defined by their context eg + quite different for reals and in t

QuoteRef: cbb_1973 ;;3/13/74 file processor: follow links and handle interrupts, in the sense that the instructions themselves are handled automatically (are themselves files)

QuoteRef: cbb_1973 ;;3/15/74 interrupt save-restore is so that the words remain independent--essential running parallel on same equipment

QuoteRef: cbb_1973 ;;3/19/74 multiplicative floating point errors: (b[n]-b[n]')*(16^(n-1))(a1+a2/16)((16)) last term if normalization (ca. a1*b1 <. 16) if no normalization, error decreases by ca a1/16

QuoteRef: cbb_1973 ;;3/19/74 state save is required only if want to retain control over the long run

QuoteRef: cbb_1973 ;;3/27/74 feeling that precedence should be right to left to =

QuoteRef: cbb_1973 ;;3/30/74 output formats are a form of files i.e. co-routines

QuoteRef: cbb_1973 ;;4/19/74 some symbol to say reuse this expression without computing it

QuoteRef: cbb_1973 ;;4/22/74 definition-- to fix or mark the limits of

QuoteRef: cbb_1973 ;;4/24/74 Waitfor storage and Signal storage to implement conditions

QuoteRef: cbb_1973 ;;4/25/74 A program is a sequence of true statements-- that are made true eg a=b

QuoteRef: cbb_1973 ;;5/16/74 a whole ring can only be known through its parts, its entry points

QuoteRef: cbb_1973 ;;5/16/74 rings with labels being entry points to rings i.e. a starting point where one can grab hold of the ring

QuoteRef: cbb_1973 ;;5/27/74 identity (symbol) operation is map literal of number symbols and number operations are map literals

QuoteRef: cbb_1973 ;;5/27/74 A map gives an entry in a ring-- a holding point. eg, what is this persons name-- Fred i.e., name is an entry to this person

QuoteRef: cbb_1973 ;;5/27/74 The origin of a map is the name of a ring?

QuoteRef: cbb_1973 ;;6/21/74 want to have control in one place as far as possible

QuoteRef: cbb_1973 ;;6/25/74 entry point: where (label), how (type), when (boolean)

QuoteRef: cbb_1973 ;;7/6/74 error handling is a matter of backing up

QuoteRef: cbb_1973 ;;7/10/74 rings exist in time. they can only be entered at certain times

QuoteRef: cbb_1973 ;;7/10/74 when a ring terminates control is normally brought back a level. alternative is abnormal return which has a cause

QuoteRef: cbb_1973 ;;7/13/74 a language that brings out the form, the structure of an idea

QuoteRef: cbb_1973 ;;?? do...end for looping ring and begin...end for straight line

QuoteRef: cbb_1973 ;;?? a ring has knowledge of its caller its present position and other entry points

QuoteRef: cbb_1973 ;;?? a ring is entered and provides a path

QuoteRef: cbb_1973 ;;?? what a ring is made up of is not important, eg microcode could call the system

QuoteRef: cbb_1973 ;;?? tasking is dealing the rings as objects, text with maps, action with entries and ideas with objects

QuoteRef: cbb_1973 ;;?? if an element can't be found the ring terminates and a next ring is found

QuoteRef: cbb_1973 ;;?? operations are functionals on rings

QuoteRef: cbb_1973 ;;?? entry leaving action eg #entry/ exit/:

7/13/74 ;;Quote: a lot of debugging is knowing which structures are intact; i.e., a bug is the breaking of some structure

QuoteRef: cbb_1973 ;;7/16/74 entries are closely related to symbols

QuoteRef: cbb_1973 ;;7/14/74 formally any program at a given time is == to a linear straightforward no loops, no branches program

QuoteRef: cbb_1973 ;;8/18/74 value is in terms of some set of literals

QuoteRef: cbb_1973 ;;8/18/74 the value of a cow is not the cow but in some logical units

QuoteRef: cbb_1973 ;;8/18/74 value is in terms of some set of literals

QuoteRef: cbb_1973 ;;8/18/74 the value of a cow is not the cow but in some logical units

QuoteRef: cbb_1973 ;;8/22/74 a ring itself is not available publicly

QuoteRef: cbb_1973 ;;8/22/74 type is related to other types forms a web touches every point

QuoteRef: cbb_1973 ;;8/22/74 an entry has a value, a public quantity. its type is how the entry is recognized.

QuoteRef: cbb_1973 ;;9/3/74 language in which to write a language, like relay experimentation

QuoteRef: cbb_1973 ;;9/24/74 idea representation by a collection of objects

QuoteRef: cbb_1973 ;;9/26/74 space of ideas to representation space to occurrence

QuoteRef: cbb_1973 ;;11/7/74 a and b have the same value if f(a) and f(b) always have the same value

QuoteRef: cbb_1973 ;;11/16/74 produce a language like arithmetic expressions

QuoteRef: cbb_1973 ;;11/24/74 Maps are sets of entries seen as parts, while rings (worms) are sets of entries seen as wholes

QuoteRef: cbb_1973 ;;11/24/74 Rings are internal forms while maps are external forms

QuoteRef: cbb_1973 ;;11/24/74 dealing with objects and how the objects are transformed, e.g., APL

QuoteRef: cbb_1973 ;;12/2/74 programming occurs in an environment

QuoteRef: cbb_1973 ;;12/24/74 Maps are extended up to a contradiction

QuoteRef: cbb_1973 ;;12/26/74 an entry is an access to another world

QuoteRef: cbb_1973 ;;12/26/74 an entry is an idea, a possibility of action

QuoteRef: cbb_1973 ;;12/26/74 ideas are like programming. the materials are very poor, more using words to describe abstract ideas, the words don't force their own truth

QuoteRef: cbb_1973 ;;1/5/75 Can always see symbol as static (name) or active (value)

QuoteRef: cbb_1973 ;;1/22/75 going across a boundary punches a visible hole

QuoteRef: cbb_1973 ;;1/22/75 an entry is public access

QuoteRef: cbb_1973 ;;2/3/75 tokens can be uniquely determined within a minimum neighborhood of the token.

QuoteRef: cbb_1973 ;;2/3/75 see a string constant as a string of characters not tokens.

QuoteRef: cbb_1973 ;;2/6/75 entry must be recognizable

QuoteRef: cbb_1973 ;;2/6/75 a pattern is a class which partitions entries into member or not

QuoteRef: cbb_1973 ;;2/7/75 entry definition is definition of class

QuoteRef: cbb_1973 ;;2/7/75 classes are universals while entries are particulars

QuoteRef: cbb_1973 ;;2/8/75 entry must be recognizable

2/16/75 ;;Quote: complicated systems look simple when split up; life is the opposite of this

2/16/75+;;Quote: can't really split up life and not simple if do split

QuoteRef: cbb_1973 ;;3/16/75? backtracking on a tree like popping a level in program execution i.e. program is searching for an end

QuoteRef: cbb_1973 ;;3/20/75 horizontal entries a set, vertical a list, and embedding entry definition

QuoteRef: cbb_1973 ;;3/26/75 operations as literal maps eg +(1,2) like a(1,2) both access a value

QuoteRef: cbb_1973 ;;3/26/75 a+b defines the meaning of the value (a,b) within the object + [+(a,b)]

QuoteRef: cbb_1973 ;;3/26/75 problem of i/o is converting a stream (undifferentiated) to a tree (accessing)

QuoteRef: cbb_1973 ;;5/9/75 We see things in terms of a window. Local understanding

QuoteRef: cbb_1973 ;;6/24/75 Have both the structured and linear representation

QuoteRef: cbb_1973 ;;8/8/75 Locally the amount of information is finite

QuoteRef: cbb_1973 ;;8/9/75 problems of preset day programs is that they are loosely connected

QuoteRef: cbb_1973 ;;8/9/75 eg entries.. ways of crossing boundaries

QuoteRef: cbb_1973 ;;9/10/75 locally determined grammars

QuoteRef: cbb_1973 ;;12/4/75 problem with indentation is to add something must change all indentation

QuoteRef: cbb_1973 ;;4/18/76 Bob Boeri: define the language in terms of itself, like a dictionary

9/21/76 ;;Quote: a word is in a language if, through that language, we can understand the word

10/26/76 ;;Quote: a program defines the initial conditions of a computer or state machine

QuoteRef: cbb_1973 ;;11/1/76 idea in one of the display editors in survey of editors -- display only first 20 words of a line.

QuoteRef: cbb_1973 ;;12/12/76 Localized viewpoint-- what is constant need not be indicated

12/12/76 ;;Quote: a variable is an abstraction of an operand

QuoteRef: cbb_1973 ;;12/12/76 block made up of references to blocks (names)

QuoteRef: cbb_1973 ;;12/12/76 self referencing requires abstraction

QuoteRef: cbb_1973 ;;12/12/76 Operands are parallel sets while operators are a sequence

QuoteRef: cbb_1973 ;;12/12/76 Taking an object as parallel components or serial components is a matter of interpretation (map or ring)

QuoteRef: cbb_1973 ;;12/16/76 have block element selectors on fixed blocks and on arguments of an application eg DBL A means A,A FST F A mean F A.1, A(2..n) then FST DBL A.B = DBL A,A,B = A,A,A,B or INVERT B means B.n. INVERT B(1..n-1)

QuoteRef: cbb_1973 ;;12/16/76 block machine-- bounded blocks of components (terminal-mark, block-mark selector-mark, application), reduction of a selector-mark block is an element of that block or null (can't be an application?), reduction of a block-mark block is the corresponding block with its parameter block set a block is reduced if it contains only terminals(includes null)

QuoteRef: cbb_1973 ;;12/16/76 best if fixed block size

QuoteRef: cbb_1973 ;;12/16/76 conditional application is (1..0) eg B(1..0) A is the null element

QuoteRef: cbb_1973 ;;12/17/76 machine operations are condensed selections on a block eg inc is the block (1,2,3,4,...) so 0 selects 1, 1 selects 2 etc.

QuoteRef: cbb_1973 ;;12/25/76 block machine is Lisp i.e. name of list, car and cdr selectors, lambda stu

QuoteRef: cbb_1973 ;;12/25/76 Maps are selectors while rings and applicators

QuoteRef: cbb_1973 ;;1/4/77 tried basic actions-append a block component with hook, replace a hook's component, delete an appendage to a block, test for end of block, test for component equality, access component by hook, access component by next position

QuoteRef: cbb_1973 ;;7/10/77 an executable block is one consisting of numbers only

QuoteRef: cbb_1973 ;;7/10/77 machine instructions are a fairly complicated data structure

QuoteRef: cbb_1973 ;;7/12/77 with basic functions the interpreter immediately becomes complicated. the basic functions have to disappear

2/17/78 ;;Quote: portability may measure the representation level of a program; e.g., octal code is not portable

QuoteRef: cbb_1973 ;;1/21/78 going over relay networks--cyclic relays no real difference to relay networks, both worse than random transitions--only interest is singularity

QuoteRef: cbb_1973 ;;1/22/78 initial work on singularities in relay networks

QuoteRef: cbb_1973 ;;1/26/78 shown that all RQ networks have singularities & how to tell which ones

QuoteRef: cbb_1973 ;;1/26/78 singular networks--one or more stable states not reachable from other states except through unusual transitions (eg race transitions)

QuoteRef: cbb_1973 ;;1/27/78 interested in relays because show an unusual equilibrium when started from a random state

2/5/78 ;;Quote: abstraction is a visible reference to something in the mind; a node in an information web

QuoteRef: cbb_1973 ;;2/5/78 abstraction is a channel of communication between minds without reference to other beings.

QuoteRef: cbb_1973 ;;2/17/78 Many would say that efficient code is not important. I say that efficient code is your only tie to reality.

QuoteRef: cbb_1973 ;;2/20/78 will need to define a table. since it is a useful way of presenting information.

QuoteRef: cbb_1973 ;;2/27/78 A singular system is predictable in the long run but not predictable in the short run.

QuoteRef: cbb_1973 ;;2/27/78 Purna provides a visible representation of a system.

QuoteRef: cbb_1973 ;;8/7/78 The fundamental object in Purna is the name, the fundamental action is redefining a name [i.e., editing the name's definition]

QuoteRef: cbb_1973 ;;8/7/78 Each name has a static and a dynamic definition (ring/map) the dynamic definition is its value to some processor

11/11/78 ;;Quote: Thesa abstracts state transition semantics by names and definitions

QuoteRef: cbb_1973 ;;12/10/78 Purna separates application (the human side) from reduction (the machine side)

QuoteRef: cbb_1973 ;;2/3/79 IBM human factors lab- all destructive operations such as delete-line requires use of the control key as confirmation

QuoteRef: cbb_1973 ;;3/7/79 Purna is not based on reduction. There is no meaning attached to a sequence other than the sequence itself.

QuoteRef: cbb_1973 ;;4/8/79 what is the simplest recognizer-- only variables for parameters, variables identified by capital letters, instruction lookup can be the same as variable lookup. no templated variables.

QuoteRef: cbb_1973 ;;5/6/79 decided to try out note cards and pencils for developing Purna functions

QuoteRef: cbb_1973 ;;5/7/79 so a type is simply a name

QuoteRef: cbb_1973 ;;6/18/78 so process of assembling and loading is very similar

QuoteRef: cbb_1973 ;;7/21/79 what I really want is the ability to define arbitrary sequences of relocatable code

7/23/79 ;;Quote: in programming, always doing something which is similar to what was done before but seldom exactly the same

QuoteRef: cbb_1973 ;;7/29/79 dual grounds, background if waiting for user input, computation ground executed during hardware output, commands via editor

QuoteRef: cbb_1973 ;;8/4/79 determined all 1 and 2 element singularities

QuoteRef: cbb_1973 ;;8/4/79 looked at 3 element singularities but didn't find a regularity nor also there was many singularities

QuoteRef: cbb_1973 ;;8/4/79 in 1 element systems are singular, in 2 element systems 35/256 system are singular (ca 1/5)

QuoteRef: cbb_1973 ;;8/4/79 singularities are very common-- they have lots of similarities but these similarities are not strong enough to generalize, it appears that they occur in classes

QuoteRef: cbb_1973 ;;8/7/79 a programming language should not be based on a formal system i.e. the humans should be an integral part of the system

8/17/79 ;;Quote: in Thesa, always work with what was done before; modify and reorganize instead of create

QuoteRef: cbb_1973 ;;8/18/79 non-singular systems under a small disturbance will reach an equilibrium despite the disturbance, singular system will never reach an equilibrium which is insensitive to the disturbance.

QuoteRef: cbb_1973 ;;8/20/79 Would like a local removable database, a large global database, global read only memory for shared code. Global backup medium

QuoteRef: cbb_1973 ;;9/13/79 Purna is designed for defining your own language (creative). It is far easier to reuse a procedure than to redefine it (conservative)

QuoteRef: cbb_1973 ;;12/8/79 a Purna system consists of a large number of objects each defined by a small number of references to objects.