This is a great video!

They discussed and demonstrate Cedar's early text selection, copy and move commands, and compare them to Larry Tesler’s cut and paste (which didn't require any special keys or more than one mouse button). The Tioga text editor and other Cedar applications made common operations like repeatedly copying text into a document from different places very easy and streamlined (fewer actions than cut, copy and paste), by using the shift key while selecting text.

Cedar took full advantage of the three button mouse as well as the control and shift keys (for 12 combinations of actions in any context, that worked the same everywhere).

I think SunView and maybe even OpenWindows also supported a similar (but obscure) “quick paste” mode, where you hold down the special “Copy” function key, select some text without disturbing the current input focus, cursor position, or text selection, and then when you release the key, that text is pasted into the current input focus at the current position, moving the cursor forward. That way you didn’t have to lose your current selection or position, in order to just select some other text and copy it in.

Here, I found the code to do it in an old version of NeWS -- it was the cut key to move, or the paste key to copy, and it's called the "Secondary" selection (rank=Secondary):

https://github.com/duncanmak/noticias/blob/6f0a78186ee074828...

% Cut key: Either delete the primary selection (stashing it
% on the clipboard) or move the secondary selection to the
% focus, if one was made.

% Paste key:
% Insert either the secondary selection (if one was made)
% or the contents of the clipboard.

When he browses through the code, you can see a whole bunch of X11 stuff.

I believe that stuff is the port of Cedar to the Sun. Xerox PARC developed "Portable Common Runtime", which was basically the Cedar operating system runtime, on top of SunOS (1987 era SunOS, not Solaris, so no shared libraries or threads, which PCR had to provide). He demonstrates compiling a "Hello World" Cedar shell command, and (magically behind the scenes) dynamically linking it into the running shell and invoking it.

Experiences Creating a Portable Cedar.

Russ Atkinson, Alan Demers, Carl Hauser,
Christian Jacobi, Peter Kessler, and Mark Weiser.

CSL-89-8 June 1989 [P89-00DD6]

http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-89-8...

>Abstract: Cedar is the name for both a language and an environment in use in the Computer
Science Laboratory at Xerox PARC since 1980. The Cedar language is a superset of Mesa, the
major additions being garbage collection and runtime types. Neither the language nor the
environment was originally intended to be portable, and for many years ran only on D-machines
at PARC and a few other locations in Xerox. We recently re-implemented the language to make
it portable across many different architectures. Our strategy was, first, to use machine dependent C code as an intermediate language, second, to create a language-independent
layer known as the Portable Common Runtime, and third, to write a relatively large amount of
Cedar-specific runtime code in a subset of Cedar itself. By treating C as an intermediate code
we are able to achieve reasonably fast compilation, very good eventual machine code, and all
with relatively small programmer effort. Because Cedar is a much richer language than C, there
were numerous issues to resolve in performing an efficient translation and in providing
reasonable debugging. These strategies will be of use to many other porters of high-level
languages who may wish to use C as an assembler language without giving up either ease of
debugging or high performance. We present a brief description of the Cedar language, our
portability strategy for the compiler and runtime, our manner of making connections to other
languages and the Unix operating system, and some measures of the performance of our
"Portable Cedar".

PCR implemented threads in user space as virtual lightweight processes on SunOS by running several heavy weight Unix processes memory mapping the same main memory. And it also supported garbage collection. Mark Weiser worked on both PCR and the Boehm–Demers–Weiser garbage collector.

https://en.wikipedia.org/wiki/Boehm_garbage_collector

This is the 1988 "Garbage Collection in an Uncooperative Environment" paper by Hans-Juergen Boehm and Mark Weiser:

https://hboehm.info/spe_gc_paper/preprint.pdf

>Similarly, we treat any data inside the objects as potential pointers, to be followed
if they, in turn, point to valid data objects. A similar approach, but restricted to procedure frames, was used in the Xerox Cedar programming environment [19].

[19] Rovner, Paul, ‘‘On Adding Garbage Collection and Runtime Types to a Strongly-Typed, Statically Checked, Concurrent Language’’, Report CSL-84-7, Xerox Palo Alto Research Center.

http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-84-7...

My guess is that the BDW garbage collector had its roots in PCR (pun intended, in fact this entire message was just an elaborate setup ;), but I don't know for sure the exact relationship between Cedar's garbage collector, PCR's garbage collector (which is specifically for Cedar code), and the Boehm–Demers–Weiser garbage collector (which is for general C code). Does anybody know how they influenced each other, shared code, or are otherwise related? Maybe there's a circular dependency!