RFC 94
Some thoughts on Network Graphics
Some Thoughts on Network Graphics ✨🎀
okay bestie, this is RFC 94 🦋 from the Network Working Group, written by E. Harslem and J. Heafner on 3 February 1971 (NIC 5725) 💜. The header doesn't list a category, and it doesn't say what it obsoletes or updates, so there's nothing to report there 🙈.
Purpose 🌸
This note is basically our first reactions to NWG/RFC #86 💅, which was meant to give everyone a starting point for talking about and building Network graphics.
Note 86's big idea is that you interpret data structures to spit out graphic order codes for the display 🖥️. That method has worked out really well so far, so we're team keep-it 💖.
Note 86 is built around one specific vibe: a minimal graphics terminal hooked up to computing facilities at remote sites ✨. We want to embrace the bigger vibe too, where there are smart programs on both ends of the connection, not just a minimal terminal 🧚.
The proposal in Note 86 should be broadened so it can describe more complex entities, and it should be lifted up to describing more general things 🌈. Here's the plan: first we roast the limits of Note 86's details 🔥, then we suggest some extra ingredients to widen its scope, and last but not least we propose an alternate approach that turns Network conversations (where it makes sense) into symbol manipulation instead of gross detail 💅.
Comments on the Detailed Restrictions of Note 86 🙈
Okay, the detailed constraints in Note 86 are lowkey limiting 😭. They block a bunch of cool Rand display hardware features that we think (from a human factors standpoint) are needed for some current apps 💅. They also box in other nodes whose ARPA-sponsored research needs sophisticated hardware 🔥.
Some examples: the point, vector, and character capability of Note 86 leaves out line type mode, intensity control, and a lot of other attractive control operations 🎀. The max symbol sizes are too small for our big character size 🙈. All our symbols are supposed to originate at the "centroid" of the symbol instead of the lower left corner of a virtual rectangle around it 📐. Under mode control for plotting, the beam may not advance to the next character position 🦋. And 7-bit ASCII is insufficient 💀, etc.
Basically, the five list items of Note 86 aren't expressive enough. Like, there's no way to position and open a graphic compare "window" 🪟. And the problem never got around to supplying parameters that identify structure for matching, etc., that aren't actual display commands ✨.
Maybe some necessary info gathering (aka the display hardware descriptions and the characteristics of every node) has to come first, before anyone writes a detailed specification 📋. It's important that, without delay, we define a mechanism for gathering and collating this info so it doesn't slow down Network graphics development 🚀.
Some General Extensions to the Note 86 Proposal 🌈
- Display language capabilities SHOULD cover the union of current and anticipated Network graphics hardware 🖥️. Our experience poking at interactive graphics communication for researchers and non-programmers says this is not just a "motherhood" statement 🙄. Apps depend heavily on sophisticated graphics hardware, and without those features, some programs just won't get used 💀.
- The data structure SHOULD allow logical as well as pictorial representation of the user's problem 🧠. This close coupling of the meaning of a picture with the actual picture is desirable from a processing program's point of view, especially if a user is to interact with the picture 🫶. We've found this an efficient way to operate with the GRAIL Project and its derivatives here at Rand ✨. This technique is included in a recently proposed graphics language generated by Bob Anderson (Rand) and Ben Wegbreit (Harvard) 👑.
- Transmit definitions of graphics and then instances of their use 🎀. The attempt here is to raise the level of "conversation" between programs (where possible) and to reduce processing overhead 🦋. For example, if one wishes to draw lots of resistors, why not graphically define a resistor once and then transmit instances by giving the definition name accompanied by attributes? A typical form of an instance is shown below:
Item Name (position, size, intensity, scaling, labeling,
rotation, etc.)There are many examples of this approach, such as the recent work by William Newman (Utah) and many earlier studies at MIT 🌸.
- Partition the display structure for 1) static vs. dynamic information, and 2) context 🧚. Instead of refreshing an entire picture whose domain is the entire screen, we've found it useful to give the processing routine (that wishes to draw a picture) knowledge of only a named rectangular portion of the CRT and an accompanying display structure 💅. With our particular hardware we can then update only the dynamic part of a picture rather than regenerating the entire display structure 🔥. Just as important, we can logically assign areas of the CRT to different concurrent processing routines 💖. Coupled with the logical/pictorial representation noted in 2) above, this is a powerful technique 👑. Named partitions also naturally accommodate those applications requiring multiple CRTs 🌈.
- The interpreter could be context-driven, thus not restricting its output to a single set of CRT order codes ⭐. By providing cataloged descriptions such as the "forms" discussed in Note #83, the interpreter could reconfigure data destined for files, etc., as well as a display 🍓. The gain here in terms of adapting to a users' Network needs is large, and the price paid in terms of implementing this increment of the interpreter is probably small 🤌.
An Alternate Proposal ✨
okay so Note 86 brings up this case where a terminal sits on a node with a minimal HOST and talks to a remote computationally-oriented node 🖥️. The data standard that Note 86 suggests sending over the Network is literally so much gross detail 😭, and the standard language is pretty inexpressive too. It only covers a few simple notions. not it being this basic 🙈
So here's the alternative: look at communication between non-minimal nodes, meaning nodes with serious memory and computing power 💪. In that setup, the Network standard data should be a high-level macro form that stands in for all those gross details, and it has the power to handle sophisticated graphics devices 🎨. The standard language would be rich enough to express every special feature of Network display devices. main character energy, fr fr 👑
This idea comes with two problems, though 🫶.
The first one is: how can a terminal handle commands from a remote program when its hardware can't do them? The answer is that the remote program is too sophisticated for the terminal, so the connection is invalid 🚫. A terminal should NORMALLY only connect to a program that uses no more than its hardware capabilities. This concept gives us a standard where a simple terminal and a simple program can talk to each other (exactly the Note 86 proposal 💜), and a sophisticated terminal can talk to a sophisticated program in a high-level language, or it can talk to a simple program. All of that happens within the same Network standard. it's giving flexibility 🦋
The second problem is that a minimal host might not have enough facilities to translate from a powerful Network standard language into the simple, detailed order codes its terminals use 💀.
When it's needed, the minimal site's needs get handled by another Network node that provides data reconfiguration services. AN ESSENTIAL PART OF THIS PROPOSAL 🚨. The reconfiguration works from "forms" that specify the translation from the Network standard to the specific non-standard data format the minimal node needs (basically tailored to its exact hardware 🎀). Whether that ends up being graphic order codes or some intermediate form depends on the processing power and requirements of the minimal node 🌸.
Fig. 1 shows a schematic diagram of the key pieces of this reconfiguration facility 🧚. Fig. 2 shows how a local display handler uses that facility, and how it acts as a middleman for two remote nodes that need different amounts of external data reconfiguration 🍓.
Network
| ^
| |
| |
v |
+--------------+
| A Network | Local
| Process |---> Files, Programs,
| Invoking the |<--- CRTs, etc.
| Interpreter |
+--------------+
| ^
| |
| |
v |
+--------------+ +--------------+ (A user can access
| | | User's | the logical
|-->| Interpreter | | Semantic | representation of
| | | | Routines | his problem.)
| +--------------+ +--------------+
| | ^ | ^
| | | | |
| | | | |
| v | v |
| +-------------------+
| | |
| | Primitive |
| | Data Structure |
| | Operators |
| | |
| +-------------------+
| | ^
| | |
+--------------+ | |
| Data Base of | v |
| "Forms" for | +------------------+
| Reconfigu- | | Data Structure |
| ration | | Base: |
+--------------+ | 1 - Pictorial |
| 2 - Logical |
+------------------+
Fig. 1. Data Reconfiguration Service Host Providing Host Providing
Computational Facility Reconfiguration Service
+--------------------+ STANDARD +-----------------------------+
| | FORMAT | +----------+ +-----------+ |
| |------------|--| Inter- |-| Display | |
| | (of Macro | /| preter | | Handler | |
| | Form Data) |//+----------+ +-----------+ |
+--------------------+ //--------------------|-------+
// |
/( +-----------+
/ \ | Terminal |
/ \ +-----------+
/ \
/ \
/ \
NON-STD. / \ NON-STD.
(Terminal Order Codes) / \ (Detailed Data)
/ \
/ \
/ \
/ \
/ \
/ \
| |
+-------|-------+ +-------|-------+
| | | | +-----------+ |
Minimum | | | | | Display | | Minimum
Host | | | | | Handler | | Host
| | | | +-----------+ |
+-------|-------+ +-------|-------+
| |
+-----------+ +-----------+
| Terminal | | Terminal |
+-----------+ +-----------+
Fig. 2. Use of Data Reconfiguration Service [ This RFC was put into machine readable form for entry ]
[ into the online RFC archives by Sergio Kleiman]📦 where this page comes from
- ietf: rfc94 1971-02
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms