Map
Index
Random
Help
Topics
th

QuoteRef: cbb_1973

topics > all references > ThesaHelp: references c-d



Topic:
function call
Group:
memory management
Topic:
object and value equivalence
Topic:
value as an abstraction
Group:
Thesa programming system
Topic:
primitive functions
Topic:
data types in Thesa
Topic:
user-defined languages
ThesaHelp:
references c-d
Topic:
arrays
Topic:
text editing
Topic:
initialization of data
Topic:
preventing accidental errors
Topic:
expression language
Topic:
file cache
Topic:
extensible languages
Topic:
is a name a literal string or a symbol
Topic:
consistency testing
Topic:
vivid representation of programs
Topic:
backtracking
Topic:
machine code and assembly language
Topic:
localized understanding
Topic:
efficiency
Topic:
Thesa as a database of modules
Topic:
strings
Group:
grammar
Topic:
control file
Topic:
object transformation language
Topic:
packed data
Topic:
program source as truth
Topic:
discrete vs. continuous
Topic:
macros
Topic:
embedded systems
Topic:
logic programming
Topic:
numerical error
Topic:
case statement
Topic:
data type by name or tags
Topic:
goto statement
Topic:
message queues for communication
Topic:
decision table
Group:
code generation
Topic:
interrupt handler
Topic:
no need for efficiency
Topic:
exception handling by termination
Topic:
programming by sequential implementation
Topic:
string literals
Topic:
words defined by words
Topic:
event controlled processing
Topic:
program proving is infeasible
Group:
input/output
Topic:
block machines
Topic:
language flexibility
Topic:
indentation
Topic:
self reference
Group:
patterns
Topic:
function cost
Topic:
maps and rings
Topic:
compile-time execution
Topic:
interrupts
Topic:
function syntax by pattern
Topic:
assigning values to statements
Topic:
constants
Topic:
abstraction by name
Topic:
operator precedence
Topic:
editor as the UserInterface
Topic:
program execution
Topic:
program web
Topic:
unique names
Topic:
user-centered design
Topic:
string and list concatenation
Topic:
data structure literals
Topic:
entries
Topic:
rings
Topic:
co-routines
Topic:
software documentation
Topic:
definition
Topic:
pronoun reference
Topic:
default value
Topic:
input/output by accessing a variable
Topic:
maps
Topic:
generic operations and polymorphism
Topic:
input or output parameters
Topic:
save-restore
Topic:
token
Topic:
control point
Topic:
programming environment
Topic:
symbolic manipulation of formulas
Topic:
abbreviated input
ThesaHelp:
lost quotations
Topic:
entries into rings
Topic:
networks of relays
Topic:
multi-processing for a user interface
Topic:
flow diagrams and flow charts
Topic:
man-machine symbiosis
Topic:
global declarations and variables
Topic:
managing people
Topic:
deletion of information
Topic:
threaded code
Topic:
programmable controller
Topic:
programming with forms
Topic:
recursive data structures
Topic:
type variable
ThesaHelp:
references e-f
Topic:
set-oriented languages
Topic:
declaration through use
Topic:
function definition
ThesaHelp:
references g-h
Topic:
syntax analysis
Topic:
BNF grammar
Topic:
programming language standards
ThesaHelp:
ACM references f-l
ThesaHelp:
references m-o
Topic:
abstraction in programming
Topic:
procedure valued variables
Topic:
enumerated data types
Topic:
alias names
Topic:
database record
ThesaHelp:
ACM references m-z
ThesaHelp:
references sa-sz
Topic:
sections of a program
Topic:
program listing
Topic:
foreach and for all statements
Topic:
events
Topic:
boolean values, binary numbers, and bit strings
Topic:
pattern matching
Topic:
string transformation languages
Topic:
type conversion
Topic:
safe use of pointers
Topic:
index sequence for array access
Topic:
sub-sequences
Topic:
symbol table
Topic:
string operations
Topic:
attribute-value pairs as information
Topic:
quantified repetition
Topic:
structure transformation languages
Topic:
failure returning functions and expressions
Topic:
range checking
Topic:
task scheduling
Topic:
primitive data type as memory
Topic:
interactive response time
Topic:
notations for brackets
Topic:
conditional statement
Topic:
builtin functions
Topic:
virtual memory
Topic:
dynamic code modification
Topic:
in-line machine code
Topic:
pattern brackets
Topic:
notation for declarations
Group:
program control
Topic:
asynchronous processing
Topic:
execution with program stubs
Topic:
prompted input
Topic:
scrolling a window
Topic:
program construction by walk-through
Topic:
procedures as data
Topic:
conditional expression
Topic:
for loop
Topic:
macro syntax definition
Topic:
running programs in a workspace or environment
Topic:
pattern specification
Topic:
list processing
Topic:
function syntax definition
Topic:
evaluate operator
Topic:
output formatting
Topic:
notation for operations
Topic:
comments
Topic:
defensive programming
Topic:
program blocks for control
Topic:
pattern components
Topic:
simple loop
Topic:
page formatting
Topic:
actor machines
Topic:
no need for variables
Topic:
trees
Topic:
programming with a database of modules
Topic:
function library
Topic:
replacement as moving information
Topic:
sparse arrays
ThesaHelp:
references t-z
Topic:
variables for array bounds
Topic:
bugs
Topic:
vitalism, the soul
Topic:
people vs. computers
Topic:
meaning by language as a whole
Topic:
meaning of words
Topic:
state machine
Topic:
computer as state machine
Topic:
number as a named set of numbers
Group:
parameters
Topic:
using pointers in Thesa
Topic:
variable as reference to a value
Topic:
abstraction in programming language
Group:
variables
Topic:
primitive data types for Thesa
Topic:
decomposition of a system into levels
Topic:
software portability
Topic:
semantic networks
Topic:
incremental development

Reference

Barber, C.B., "from notebooks 1973-1979", 1973-1979. Google

personal notes

Notes

QuoteRef: cbb_1980
The first notes lost their dates.

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


Related Topics up

Topic: function call (28 items)
Group: memory management   (11 topics, 346 quotes)
Topic: object and value equivalence (60 items)
Topic: value as an abstraction (25 items)
Group: Thesa programming system   (11 topics, 561 quotes)
Topic: primitive functions (34 items)
Topic: data types in Thesa (92 items)
Topic: user-defined languages (38 items)
ThesaHelp: references c-d (337 items)
Topic: arrays (57 items)
Topic: text editing (34 items)
Topic: initialization of data (42 items)
Topic: preventing accidental errors (36 items)
Topic: expression language (13 items)
Topic: file cache (23 items)
Topic: extensible languages (69 items)
Topic: is a name a literal string or a symbol (23 items)
Topic: consistency testing (60 items)
Topic: vivid representation of programs (22 items)
Topic: backtracking (30 items)
Topic: machine code and assembly language (49 items)
Topic: localized understanding (43 items)
Topic: efficiency (96 items)
Topic: Thesa as a database of modules (23 items)
Topic: strings (13 items)
Group: grammar   (8 topics, 180 quotes)
Topic: control file (10 items)
Topic: object transformation language (10 items)
Topic: packed data (11 items)
Topic: program source as truth (17 items)
Topic: discrete vs. continuous (47 items)
Topic: macros (22 items)
Topic: embedded systems (26 items)
Topic: logic programming (34 items)
Topic: numerical error (19 items)
Topic: case statement (25 items)
Topic: data type by name or tags (29 items)
Topic: goto statement (25 items)
Topic: message queues for communication (36 items)
Topic: decision table (29 items)
Group: code generation   (30 topics, 585 quotes)
Topic: interrupt handler (20 items)
Topic: no need for efficiency (28 items)
Topic: exception handling by termination (16 items)
Topic: programming by sequential implementation (26 items)
Topic: string literals (3 items)
Topic: words defined by words (24 items)
Topic: event controlled processing (46 items)
Topic: program proving is infeasible (46 items)
Group: input/output   (4 topics, 74 quotes)
Topic: block machines (8 items)
Topic: language flexibility (34 items)
Topic: indentation (25 items)
Topic: self reference (27 items)
Group: patterns   (8 topics, 179 quotes)
Topic: function cost (8 items)
Topic: maps and rings (15 items)
Topic: compile-time execution (17 items)
Topic: interrupts (25 items)
Topic: function syntax by pattern (15 items)
Topic: assigning values to statements (7 items)
Topic: constants (21 items)
Topic: abstraction by name (29 items)
Topic: operator precedence (13 items)
Topic: editor as the UserInterface (10 items)
Topic: program execution (8 items)
Topic: program web (8 items)
Topic: unique names (57 items)
Topic: user-centered design (65 items)
Topic: string and list concatenation (9 items)
Topic: data structure literals (9 items)
Topic: entries (12 items)
Topic: rings (21 items)
Topic: co-routines (13 items)
Topic: software documentation (64 items)
Topic: definition (16 items)
Topic: pronoun reference (23 items)
Topic: default value (8 items)
Topic: input/output by accessing a variable (8 items)
Topic: maps (6 items)
Topic: generic operations and polymorphism (65 items)
Topic: input or output parameters (5 items)
Topic: save-restore (4 items)
Topic: token (8 items)
Topic: control point (3 items)
Topic: programming environment (46 items)
Topic: symbolic manipulation of formulas (12 items)
Topic: abbreviated input (10 items)
ThesaHelp: lost quotations (15 items)
Topic: entries into rings (6 items)
Topic: networks of relays (27 items)
Topic: multi-processing for a user interface (14 items)
Topic: flow diagrams and flow charts (21 items)
Topic: man-machine symbiosis (46 items)
Topic: global declarations and variables (33 items)
Topic: managing people (64 items)
Topic: deletion of information (11 items)
Topic: threaded code (18 items)
Topic: programmable controller (9 items)
Topic: programming with forms (26 items)
Topic: recursive data structures (18 items)
Topic: type variable (5 items)
ThesaHelp: references e-f (168 items)
Topic: set-oriented languages (20 items)
Topic: declaration through use (4 items)
Topic: function definition (25 items)
ThesaHelp: references g-h (299 items)
Topic: syntax analysis (29 items)
Topic: BNF grammar (9 items)
Topic: programming language standards (10 items)
ThesaHelp: ACM references f-l (241 items)
ThesaHelp: references m-o (268 items)
Topic: abstraction in programming (67 items)
Topic: procedure valued variables (34 items)
Topic: enumerated data types (17 items)
Topic: alias names (39 items)
Topic: database record (22 items)
ThesaHelp: ACM references m-z (280 items)
ThesaHelp: references sa-sz (237 items)
Topic: sections of a program (9 items)
Topic: program listing (14 items)
Topic: foreach and for all statements (16 items)
Topic: events (44 items)
Topic: boolean values, binary numbers, and bit strings (44 items)
Topic: pattern matching (42 items)
Topic: string transformation languages (17 items)
Topic: type conversion (33 items)
Topic: safe use of pointers (102 items)
Topic: index sequence for array access (16 items)
Topic: sub-sequences (13 items)
Topic: symbol table (4 items)
Topic: string operations (20 items)
Topic: attribute-value pairs as information (53 items)
Topic: quantified repetition (11 items)
Topic: structure transformation languages (7 items)
Topic: failure returning functions and expressions (24 items)
Topic: range checking (20 items)
Topic: task scheduling (49 items)
Topic: primitive data type as memory (29 items)
Topic: interactive response time (32 items)
Topic: notations for brackets (9 items)
Topic: conditional statement (8 items)
Topic: builtin functions (6 items)
Topic: virtual memory (32 items)
Topic: dynamic code modification (15 items)
Topic: in-line machine code (5 items)
Topic: pattern brackets (15 items)
Topic: notation for declarations (20 items)
Group: program control   (27 topics, 547 quotes)
Topic: asynchronous processing (30 items)
Topic: execution with program stubs (5 items)
Topic: prompted input (5 items)
Topic: scrolling a window (9 items)
Topic: program construction by walk-through (26 items)
Topic: procedures as data (22 items)
Topic: conditional expression (11 items)
Topic: for loop (18 items)
Topic: macro syntax definition (10 items)
Topic: running programs in a workspace or environment (14 items)
Topic: pattern specification (15 items)
Topic: list processing (15 items)
Topic: function syntax definition (17 items)
Topic: evaluate operator (7 items)
Topic: output formatting (11 items)
Topic: notation for operations (18 items)
Topic: comments (23 items)
Topic: defensive programming (22 items)
Topic: program blocks for control (20 items)
Topic: pattern components (15 items)
Topic: simple loop (15 items)
Topic: page formatting (16 items)
Topic: actor machines (2 items)
Topic: no need for variables (13 items)
Topic: trees (21 items)
Topic: programming with a database of modules (94 items)
Topic: function library (50 items)
Topic: replacement as moving information (4 items)
Topic: sparse arrays (6 items)
ThesaHelp: references t-z (309 items)
Topic: variables for array bounds (7 items)
Topic: bugs (65 items)
Topic: vitalism, the soul (65 items)
Topic: people vs. computers (54 items)
Topic: meaning by language as a whole (26 items)
Topic: meaning of words (21 items)
Topic: state machine (67 items)
Topic: computer as state machine (20 items)
Topic: number as a named set of numbers (15 items)
Group: parameters   (10 topics, 145 quotes)
Topic: using pointers in Thesa (49 items)
Topic: variable as reference to a value (21 items)
Topic: abstraction in programming language (47 items)
Group: variables   (10 topics, 128 quotes)
Topic: primitive data types for Thesa (82 items)
Topic: decomposition of a system into levels (49 items)
Topic: software portability (43 items)
Topic: semantic networks (42 items)
Topic: incremental development (74 items)

Collected barberCB 1980
Copyright © 2002-2008 by C. Bradford Barber. All rights reserved.
Thesa is a trademark of C. Bradford Barber.