
Demonstration of the Xerox PARC Cedar integrated environment (2019) [video] - pmarin
https://www.youtube.com/watch?v=z_dt7NG38V4
======
mrandish
About a decade ago I worked for a very senior and highly respected guy who was
near the end of his career. After working closely with him for over a year he
decided it was finally time to retire and he left.

Recently, many years later, I'm reading an interesting history of Xerox Parc
during that "golden era" where a small group created all the stuff that rocked
Steve Jobs world during the legendary 70s demo that led to those concepts
ending up in the Lisa and Mac (ie GUI, mouse, etc), and I see that my former
boss was on that team and wrote key parts of that stuff early in his career. I
look on YouTube and he's one of the people demoing on stage at that big event
where the original team got all that code working again on restored original
hardware to recreate 'the mother of all demos' so it could be recorded for
posterity.

I reached out to him and said, "Dude, I worked with you all that time and you
never thought to even mention in all those conversations we had about
interface design that you were one of the people who invented a lot of what
became computer interaction as we know it?"

He replied, "Oh, that. I didn't think it was important."

It just says a lot about the character and class of these guys, especially in
an era where I see too many people who go out of their way to ensure everyone
they work with knows they were "one of the first 50 employees at..." (some
recent unicorn startup).

~~~
snickmy
I've recently saw a documentary on General Magic. I've been working in tech
for 15 years and had never heard about that company. I think we all have a lot
to learn, and should pay more respects to the giants that took us here.

------
williamDafoe
Once upon a time I was wandering through PARC and I wandered into a closet
where a giant Ceder machine (Dorado) was running. It has an un flipping
believable 512x512 COLOR display! It was an entire eight foot tall rack and
its fans for the ECL logic roared like a hurricane. This deluxe personal
computer from Xerox ran as fast as a Decsystem 20 massive time sharing machine
that normally hosted 20-40 users.

Unfortunately everybody at PARC believed Butler lampson when he said you could
write a personal computer program and if it crashed once per day that's okay
you just pressed a button and rebooted it! Everybody took that to heart and
wrote buggy unstable software and all the D-machines (wildflower architecture)
including Dorado Dolphin Dandelion and Dandetiger crashed once per hour! it
seems Butler lampson didn't consider joint probability distributions...

Xerox made okay programming environments but Pilot and Smalltalk and Interlisp
were horrible operating systems compared to UNIX v7.

~~~
Rochus
Cedar was a programming language and a development environment (not an
operating system) and also run on Solaris as demonstrated in the demo, and I
didn't see it crash during the two hour demo.

~~~
williamDafoe
Pilot would crash with probability 0.9^p, where p is the number of things you
did at once, p=4 was a limit I never surpassed. With UNIX p=30 was
commonplace.

~~~
pjmlp
It is easy not to crash, when everything that one is able to do are text based
applications.

------
Rochus
I like these presentations of the CHM very much. Cedar is an impressive
environment and it's very interesting to see where the Oberon System which I
have recently become involved with (see [https://github.com/rochus-
keller/OberonSystem](https://github.com/rochus-keller/OberonSystem)) got its
inspirations from.

------
TomMasz
I joined Xerox in the mid-90s, past the era when they were creating their own
processors and programming languages but they still couldn't resist building
one last operating system for a new digital printer/copier. The product was
late and while it was full of cool technology it was outsold by a Fuji Xerox
product built on an older digital printer. Cool doesn't always translate into
something customers will pay for.

------
Aloha
It's too bad little of this software has ever been released to the world.

------
DonHopkins
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...](https://github.com/duncanmak/noticias/blob/6f0a78186ee074828cbdf730169ad99aa3c64edd/etc/NeWS-2.0/NDE/OLUI.ps#L63)

    
    
        % 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...](http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-89-8_Experiences_Creating_a_Portable_Cedar.pdf)

>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](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](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...](http://www.bitsavers.org/pdf/xerox/parc/techReports/CSL-84-7_On_Adding_Garbage_Collection_and_Runtime_Types_to_a_Strongly-
Typed_Statically-Checked_Concurrent_Language.pdf)

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!

~~~
klotz
I remember using the Boehm GC in C++ in 1989. I wrote a Symbolics Lisp to G++
compiler called XL when. I was at Fuji Xerox and PARC and used it to convert
Statice, the first object-oriented database, from Lisp to C++. The server side
was a transactional block server and didn't do much consing, but the code flow
for the Lisp side did not conveniently map into the C++ stack/ctor/dtor model
of memory allocation, so I used the Boehm GC. sadly, the compiler, XL, got
lost in a tar fire.

~~~
nibbula
Like a literal tar fire? Or a tar format archive fire? Or is that a California
expression I'm not familiar with?

Also this makes me have a sick curiosity if one could have transpiled a whole
Genera world to C with cfront or something then loaded it back in with
Symbolics C and have it work?

------
pmarin
Actual demonstration starts at 14:30

