As per Relevance of the word information, we have this rfc below:
Network Working Group 4691
RFC-5 Jeff
June 2, l969
:DEL, 02/06/69 1010:58 JFR ; .DSN=1; .LSP=0; ['=] AND NOT SP ; ['?];
dual transmission
The Decode-Encode Language (DEL) is a machine independent
tailored to two specific computer network tasks
accepting input codes from interactive consoles, giving
feedback, and packing the resulting information into message
packets for network transmissin
and accepting message packets from another computer,
them, building trees of display information, and sending
information to the user at his interactive station
This is a working document for the evolution of the DEL language
Comments should be made through Jeff Rulifson at SRI
The initial ARPA network working group met at SRI on October 25-26,
1968.
It was generally agreed beforehand that the runmning of
programs across the network was the first problem that would
faced
This group, already in agreement about the underlaying notions
a DEL-like approach, set down some terminology, expectations
DEL programs, and lists of proposed semantic capability
At the meeting were Andrews, Baray, Carr, Crocker, Rulifson,
Stoughton
A second round of meetings was then held in a piecemeal way
Crocker meet with Rulifson at SRI on November 18, 1968.
resulted in the incorporation of formal co-routines
and Stoughton meet with Rulifson at SRI on Decembeer 12, 1968.
was decided to meet again, as a group, probably at UTAH, in
January 1969.
The first public release of this paper was at the BBN NET meeting
Cambridge on February 13, 1969.
NET STANDARD TRANSLATORS
NST The NST library is the set of programs necessary to
efficiently with the code compiled at the user sites from the
programs it receives. The NST-DEL approach to NET interactive
communication is intended to operate over a broad spectrum
The lowest level of NST-DEL usage is direct transmission to
server-host, information in the same format that user
would receive at the user-host
In this mode, the NST defaults to inaction. The DEL
does not receive universal hardware representation input but
input in the normal fashion for the user-host
And the DEL 1 program becomes merely a message builder
sender
A more intermediate use of NST-DEL is to have echo tables for
TTY at the user-host
In this mode, the DEL program would run a full duplex TTY
the user
It would echo characters, translate them to the character set
of the server-host, pack the translated characters in messages
and on appropriate break characters send the messages
When messages come from the server-host, the DEL program
translate them to the user-host character set and print them
his TTY
A more ambitious task for DEL is the operation of large
display-oriented systems from remote consoles over the NET
Large interactive systems usually offer a lot of feedback
the user. The unusual nature of the feedback make
impossible to model with echo table, and thus a user
must be activated in a TSS each time a button state is changed
This puts an unnecessarily large load on a TSS, and if
system is being run through the NET it could easily load
systems
To avoid this double overloading of TSS, a DEL program
run on the user-host. It will handle all the
feedback, much like a complicated echo table. At
button pushes, message will be sent to the server-host
display updates received in return
One of the more difficult, and often neglected, problems is
effective simulation of one nonstandard console on another non
standard console
We attempt to offer a means of solving this problem
the co-routine structure of DEL programs. For
complicated interactive systems, part of the DEL
will be constructed by the server-host programmers
Interfaces between this program and the input stream
easily be inserted by programmers at the user-host site
UNIVERSAL HARDWARE
To minimize the number of translators needed to map any facility'
user codes to any other facility, there is a universal
representation
This is simply a way of talking, in general terms, about all
hardware devices at all the interactive display stations in the
network
For example, a display is thought of as being a square,
mid-point has coordinates (0.0), the range is -1 to 1 on
axes. A point may now be specified to any accuracy, regardless
the particular number of density of rastor points on a display
The representation is discussed in the semantic
accompanying the formal description of DEL
INTRODUCTION TO THE NETWORK STANDARD TRANSLATOR (NST
Suppose that a user at a remote site, say Utah, is entered in
AHI system and wants to run NLS
The first step is to enter NLS in the normal way. At that
the Utah system will request a symbolic program from NLS
REP This program is written in DEL. It is called the
Remote Encode Program (REP).
The program accepts input in the Universal
Representation and translates it to a form usable by NLS
It may pack characters in a buffer, also do some
feedback
When the program is first received at Utah it is compiled
loaded to be run in conjunction with a standard library
All input from the Utah console first goes to the NLS NEP. It
processed, parsed, blocked, translated, etc. When NEP receives
character appropriate to its state it may finally
transfers to the 940. The bits transferred are in a
acceptable to the 940, and maybe in a standard form so that
NLSW need not differentiate between Utah and other NET users
ADVANTAGES OF
After each node has implemented the library part of the NST,
need only write one program for each subsystem, namely
symbolic file it sends to each user that maps the NET
representation into its own special bit formats
This is the minimum programming that can be expected if
console is used to its fullest extent
Since the NST which runs the encode translation is coded at
user site, it can take advantage of hardware at its consoles
the fullest extent. It can also add or remove hardware
features without requiring new or different translation
from the host
Local users are also kept up to date on any changes in the
offered at the host site. As new features are added
the host programmers change the symbolic encode program.
this new program is compiled and used at the user site, the
features are automatically included
The advantages of having the encode translation
transferred symbolically should be obvious
Each site can translate any way it sees fit. Thus machine
for each site can be produced to fit that site; faster
times and greater code density will be the result
Moreover, extra symbolic programs, coded at the user site,
be easily interfaced between the user's monitor system and
DEL program from the host machine. This should ease
problem of console extension (e.g. accommodating unusual keys
buttons) without loss of the flexibility needed for man-
interaction
It is expected that when there is matching hardware, the
programs will take this into account and avoid any
computing. This is immediately possible through the
translation constructs of DEL. It may someday be possible
program composition (when Crocker tells us how??)
AHI NLS - USER CONSOLE COMMUNICATION - AN
BLOCK
The right side of the picture represents functions done at
user's main computer; the left side represents those done at
host computer
Each label in the picture corresponds to a statement with
same name
There are four trails associated with this picture. The
links (in a forward direction) the labels which are
only with network information. The second links the
information flow (again in a forward direction). The last
are equivalent to the first two but in a backward direction
They may be set with pointers t1 through t4 respectively
[">tif:] OR I" >nif"]; ["
USER-TO-HOST
Keyboard is the set of input devices at the user's console
Input bits from stations, after drifting through levels of
and interrupt handlers, eventually come to the encode translator
[>nif(encode)]
Encode maps the semi-raw input bits into an input stream in
form suited to the serving-host subsystem which will process
input. [>nif(hrt)
The Encode program was supplied by the server-host
when the subsystem was first requested. It is sent to the
machine in symbolic form and is compiled at the user
into code particularly suited to that machine
It may pack to break characters, map multiple characters
single characters and vice versa, do character translation,
give immediate feedback to the user
1 dm Immediate feedback from the encode translator first goes
local display management, where it is mapped from the NET
to the local display hardware
A wide range of echo output may come from the
translator. Simple character echoes would be a minimum,
command and machine-state feedback will be common
It is reasonable to expect control and feedback functions
even done at the server-host user stations to be done in
display control. For example, people with high-speed
may want to selectively clear curves on a Culler display,
function which is impossible on a storage tube
Output from the encode translator for the server-host goes to
invisible IMP, is broken into appropriate sizes and labeled by
encode translator, and then goes to the NET-to-host translator
Output from the user may be more than on-line input. It may
larger items such as computer-generated data, or
generated and used exclusively at the server-host site
stored at the user-host site
Information of this kind may avoid translation, if it is already
server-host format, or it may undergo yet another kind of
if it is a block of data
hrp It finally gets to the host, and must then go through
host reception program. This maps and reorders the
transmission-style packets of bits sent by the encode
into messages acceptable to the host. This program may well
part of the monitor of the host machine. [>tif(net mode)
HOST-TO-USER
decode Output from the server-host initially goes through decode
a translation map similar to, and perhaps more complicated than
the encode map. [>nif(urt)>tif(imp ctrl)
This map at least formats display output into a
logical-entity output stream, of which meaningful pieces may
dealt with in various ways at the user site
The Decode program was sent to the host machine at the
time that the Encode program was sent to the user machine
The program is initially in symbolic form and is
for efficient running at the host machine
Lines of charaters should be logically identified so
different line widths can be handled at the user site
Some form of logical line identification must also be made
For example, if a straight line is to be drawn across
display this fact should be transmitted, rather than
series of 500 short vectors
As things firm up, more and more complicated
display information (in the manner of LEAP) should be
and accommodated at user sites so that the responsibility
real-time display manipulation may shift closer to the user
imp ctrl The server-host may also want to send
information to IMPs. Formatting of this information is done
the host decoder. [>tif(urt)
The other control information supplied by the host decoder
message break up and identification so that proper assembly
sorting can be done at the user site
From the host decoder, information does to the invisible IMP,
directly to the NET-to-user translator. The only operation
on the messages is that they may be shuffled
urt The user reception translator accepts messages from
user-site IMP 1 and fixes them up for user-site display.
[>nif(d ctrl)>tif(prgm ctrl)
The minimal action is a reordering of the message pieces
dctrl For display output, however, more needs to be done.
NET logical display information must be put in the format
the user site. Display control does this job. Since
coordinates between (encode) and (decode) it is able to
features of display management local to the user site
[>nif(display)
prgmctrl Another action may be the selective translation
routing of information to particular user-site subsystems
[>tif(dctrl)
For example, blocks of floating-point information may
converted to user-style words and sent, in block form, to
subsystem for processing or storage
The styles and translation of this information may well be a
compact binary format suitable for quick translation,
than a print-image-oriented format
(display) is the output to the user. [
USER-TO-HOST INDIRECT
(net mode) This is the mode where a remote user can link to a
indirectly through another node. [
DEL
NOTES FOR NLS
All statements in this branch which are not part of the
must end with a period
To compile the DEL compiler
Set this pattern for the content analyzer ( (symbol for up arrow)P
SE(P1) <-"-;). The pointer "del" is on the first character of pattern
Jump to the first statement of the compiler. The pointer "c
is on this statement
And output the compiler to file ( '/A-DEL' ). The pointer "f
is on the name of the file for the compiler output -
-meta file (k=100.m=300,n=20,s=900)
file = mesdecl $declaration $procedure "FINISH";
procedure =
procname (
(
type "FUNCTION" /
"PROCEDURE" ) .id (type .id / -empty)) /
"CO-ROUTINE") ' /
$declaration labeledst $(labeledst ';) "endp.";
labeledst = ((left arrow symbol).id ': / .empty) statement
type = "INTEGER" / "REAL" ;
procname = .id
Functions are differentiated from procedures to aid compilers
better code production and run time checks
Functions return values
Procedures do not return values
Co-routines do not have names or arguments. Their
envocation points are given the pipe declaration
It is not clear just how global declarations are to be??
declaration = numbertype / structuredtype / label / lcl2uhr /
uhr2rmt / pipetype
numbertype = : ("REAL" / "INTEGER") ("CONSTANT" conlist /
varlist);
conlist =
.id '(left arrow symbol)
$('. .id '(left arrow symbol)constant);
varlist =
.id ('(left arrow symbol)constant / .empty
$('. .id('(left arrow symbol)constant / .empty));
idlist = .id $('. .id);
structuredtype = (tree" / "pointer" / "buffer" ) idlist
label = "LABEL1" idlist
pipetype = PIPE" pairedids $(', pairedids);
pairedids = .id .id
procname = .id
integerv = .id
pipename = .id
labelv = .id
Variables which are declared to be constant, may be put
read-only memory at run time
The label declaration is to declare cells which may contain
machine addresses of labels in the program as their values. This
is not the B5500 label declaration
In the pipe declaration the first .ID of each pair is the name
the pipe, the second is thke initial starting point for the pipe
exp = "IF" conjunct "THEN" exp "ELSE" exp
sum = term (
'+ sum /
'- sum /
-empty);
term = factor (
'* term /
'/ term /
'(up arrow symbol) term /
.empty);
factor = '- factor / bitop
bitop = compliment (
'/' bitop /
'/'\ bitop /
'& bitop / (
.empty);
compliment = "--" primary / primary
(symbol for up arrow) means mod. and /\ means exclusive or
Notice that the uniary minus is allowable, and parsed so you
write x*-y
Since there is no standard convention with bitwise operators,
all have the same precedence, and parentheses must be used
grouping
Compliment is the l's compliment
It is assumed that all arithmetic and bit operations take place
the mode and style of the machine running the code. Anyone
takes advantage of word lengths, two's compliment arithmetic, etc
will eventually have problems
primary =
constant /
builtin /
variable / (
block /
'( exp ');
variable = .id (
'(symbol for left arrow) exp /
'( block ') /
.empty);
constant = integer / real / string
builtin =
mesinfo /
cortnin /
("MIN" / "MAX") exp $('. exp) '/ ;
parenthesized expressions may be a series of expressions.
value of a series is the value of the last one executed at run time
Subroutines may have one call by name argument
Expressions may be mixed. Strings are a big problem?
also wants to get rid of real numbers!!
CONJUNCTIVE
conjunct = disjunct ("AND" conjunct / .empty);
disjunct = negation ("OR" negation / .empty);
negation = "NOT" relation / relation
relation =
'( conjunct ') /
sum (
"<=" sum /
">=" sum /
'< sum /
'> sum /
'= sum /
'" sum /
.empty);
The conjunct construct is rigged in such a way that a
which is not a sum need not have a value, and may be
using jumps in the code. Reference to the conjunct is made
in places where a logical decision is called for (e.g. if
while statements).
We hope that most compilers will be smart enough to
unnecessary evaluations at run time. I.e a conjunct in which
left part is false or a disjunct with the left part true need
have the corresponding right part evaluated
ARITHMETIC
statement = conditional / unconditional
unconditional = loopst / cases / cibtrikst / uist / treest /
block / null / exp
conditional = "IF" conjunct "THEN" unconditional (
"ELSE" conditional /
.empty);
block = "begin" exp $('; exp) "end";
An expressions may be a statement. In conditional statements
else part is optional while in expressions it is mandatory.
is a side effect of the way the left part of the syntax rules
ordered
SEMI-TREE MANIPULATION AND
treest = setpntr / insertpntr / deletepntr
setpntr = "set" "pointer" pntrname "to" pntrexp
pntrexp = direction pntrexp / pntrname
insertpntr = "insert" pntrexp "as
(("left" / "right") "brother") /
(("first" / "last: ) "daughter") "of" pntrexp
direction =
"up" /
"down" /
"forward" /
"backward: /
"head" /
"tail";
plantree = "replace" pntrname "with" pntrexp
deletepntr = "delete: pntrname
tree = '( tree1 ') ;
tree1 = nodename $nodename ;
nodename = terminal / '( tree1 ');
terminal = treename / buffername / point ername
treename = id
treedecl = "pointer" .id / "tree" .id
Extra parentheses in tree building results in linear subcategorization
just as in LISP
FLOW AND
controlst = gost / subst / loopstr / casest
GO TO
gost = "GO" "TO" (labelv / .id);
assignlabel = "ASSIGN" .id "TO" labelv
subst = callst / returnst / cortnout
callst = "CALL" procname (exp / .emptyu);
returnst = "RETURN" (exp / .empty);
cortnout = "STUFF" exp "IN" pipename
cortnin = "FETCH" pipename
FETCH is a builtin function whose value is computed by
the named co-routine
LOOP
loopst = whilest / untilst / forst
whilest = "WHILE" conjunct "DO" statement
untilst = "UNTIL" conjunct "DO" statement
forst = "FOR" integerv '- exp ("BY" exp / .empty) "TO"
"DO" statements
The value of while and until statements is defined to be
and true (or 0 and non-zero) respectively
For statements evaluate their initial exp, by part, and to
once, at initialization time. The running index of
statements is not available for change within the loop, it
only be read. If, some compilers can take advantage of
(say put it in a register) all the better. The increment
the to bound will both be rounded to integers during
initialization
CASE
casest = ithcasest / condcasest
ithcasest = "ITHCASE" exp "OF" "BEGIN" statement $(';
statement) "END";
condcasest = "CASE" exp "OF" "BEGIN" condcs $('; condcs
"OTHERWISE" statement "END";
condcs = conjunct ': statement
The value of a case statement is the value of the last case executed
EXTRA
null = "NULL";
I/O
iost = messagest / dspyst ;
messagest = buildmes / demand
buildmest = startmes / appendmes / sendmes
startmes = "start" "message";
appendmes = "append" "message" "byute" exp
sendmes = "send" "message";
demandmes = "demand" "Message";
mesinfo =
"get" "message" "byte
"message1" "length" /
"message" empty: '?;
mesdecl = "message" "bytes" "are" ,byn "bits" long" '..
DISPLAY
dspyst = startbuffer / bufappend / estab
startbuffer - "start" "buffer";
bufappend = "append" bufstuff $('& bufstuff);
bufstuff = :
"parameters" dspyparm $('. dspyparm) /
"character" exp /
"string"1 strilng /
"vector" ("from" exp ':exp / .empty) "to" exp '. exp /
"position" (onoff / .empty) "beam" "to" exp '= exp
curve" ;
dspyparm F :
"intensity" "to" exp /
"character" "width" "to" exp /
"blink" onoff /
"italics" onff
onoff = "on" / "off";
estab = "establish" buffername
LOGICAL
The screen is taken to be a square. The coordinates
normalized from -1 to +1 on both axes
Associated with the screen is a position register,
PREG. The register is a triple where x and y
specify a point on the screen and r is a rotation
radians, counter clockwise, from the x-axis
The intensity, called INTENSITY, is a real number in
range from 0 to 1. 0 is black, 1 is as light as
display can go, and numbers in between specify the
log of the intensity difference
Character frame size
Blink bit
BUFFER
The terminal nodes of semi-trees are either semi-tree
or display buffers. A display buffer is a series of
entities, called bufstuff
When the buffer is initilized, it is empty. If
parameters are initially appended, those in effect at
end of the display of the last node in the semi-tree will be
effect for the display of this node
As the buffer is built, the logical entities are added to it
When it is established as a buffername, the buffer
closed, and further appends are prohibited. It is only
buffername has been established that it may be used in a
building statement
LOGICAL INPUT
Joy
Light
AUDIO OUTPUT
.
SAMPLE
Program to run display and keyboard as tty
to run
input
display
DEMAND MESSAGE
While LENGTH " O
ITHCASE GETBYTE OF
ITHCASE GETBYTE OF %file area uipdate%
%literal area
%message area
%name area
%bug
%sequence specs
%filter specs
%format specs
%command feedback line
%filer area
%date time
%echo register
BEGIN %DEL control
DISTRIBUTION
Steve
Department of Computer
University of
Salt Lake City, Utah 84112
Phone 801-322-7211 X8224
Steve
Boelter
University of
Los Angeles,
Phone 213-825-4864
Jeff
Stanford Research
333
Menlo Park, California 94035
Phone 415-326-6200 X4116
Ron
Computer Research
University of
Santa Barbara, California 93106
Phone 805-961-3221
Mehmet
Corey
University of
Berkeley, California 94720
Phone 415-843-2621
if you see any problems within the linking, don't worry be happy,
this is version 0.1 of the Relevance System and you gotta expect some crappy subroutines sometimes,
just be content we did not write this in Java, which would have made this "bigger and better" HAHAHHA.
RFC documents can be found at I.E.T.F.
Relevance System Copyright © 2002 Spectrum WorldResearch
other technical nosh by ServerMasters Corporation
collaboration of BobX
