Demonstration of the Xerox PARC Cedar integrated environment (2019) [video] | Hacker News Reader

Demonstration of the Xerox PARC Cedar integrated environment (2019) [video]

youtube.com

52 pointspmarin23 comments

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

My uncle is one of those people who worked at Xerox Parc during that same era. (I'm sure he would know this person you're speaking of.)

He too is _very_ humble and reserved about the whole thing.

Then his name most likely was not Alan Kay ;-)

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.

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.

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.

Not exactly. The three main environments (Smalltalk, Interlisp-D and Cedar) took over the machine completely. Each had its own network stack, window system, et al. Those environments didn't have memory protection so from an OS perspective they were more like classic MacOS rather than current MacOS.

They weren't general purpose OSes: there was a single "environment" running bare on the machine. That's why porting Cedar, Symbolics images etc is possible: you stick the whole thing in a single address space in user space.

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.

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

I used to do a lot of development on a Dorado (usually at night -- I was low enough on the totem pole that I wouldn't grab one during the day, and used a Dolphin instead). They didn't crash all the time, at least in the InterLisp world I was using.

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) got its inspirations from.

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.

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

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!

Plus Mark Weiser did SDI, one of my favorite SunView games. :)

Pie Menus in SDI by Mark Weiser

Demonstration of Mark Weiser's Pie Menus implementation for his classic game SDI for SunView, written while snowed in at home in 1987.

https://www.youtube.com/watch?v=WTtEPbIE10I

(You can configure which icon to use for the cities, so I used icons of linear menus, that get nuked!)

Did you save a copy of the noticias repo? It's gone now.

Oops, it must be a private repo. That was a link to The NeWS Toolkit 1.0 soures, which shipped with OpenWindows 1.0, and was a lot different than TNT 2.0, which shipped with OpenWindows 2.0, and whose motto was "Twice the speed at half the size". TNT 1.0 was terribly over-engineered, which TNT 2.0 addressed.

I found the SunView 1 Beginner's Guide which explains all about "secondary selections", which are a lot like moving text in Cedar, but using the dedicated function keys [Copy], [Paste], [Cut] and [Find] on the left side of the keyboard, instead of the shift key:

http://chiclassiccomp.org/docs/content/computing/Sun/softwar...

p. 104:

6.7. Secondary Selections

A secondary selection is a selection you make while holding down a function key. The action takes place when you release the function key. This feature lets you do many Copy, Paste, Cut and Find shortcuts with function keys.

The secondary selection is always underlined. It lasts only as long as you hold down the function key. During that time, you can adjust the secondary selection the same way you adjust a primary selection.

You can also scroll while making a secondary selection, as long as you continue to hold the function key down. That way, you can adjust the selection to encompass characters that aren't currently visible in the window.

With secondary selections, you can do editing operations that require both a source and a destination, such as duplicating and moving text. Secondary selections also let you perform an operation without changing the current primary selection and insertion point.

You've already learned one method for copying text from one place to another:

- Select some text and press [Copy].

- Select the destination and press [Paste].

For an easier way to duplicate text, use secondary Paste. The example changes "strawberry" to "strawberry vanilla":

- Click LEFT to set the caret where you want the text copied.

- Hold down the [Paste] key while selecting the text to be copied. The text is underlined to indicate that it's a secondary selection.

- Release the [Paste] key. The secondary selection is pasted at the caret.

NOTE: When you use secondary Paste to get text from another window, be sure the pointer is in the "to" window when you first press the [Paste] key; otherwise the keyboard focus will shift and you'll paste in the "from" window. The secondary selection is pasted into the window that has the keyboard focus at the time you press the function key.

You can use secondary selections to specify operands for [Copy], [Paste], and [Cut], as well as for [Find].

To delete text without changing the insertion point, use secondary Cut:

- Hold down the [Cut] key while selecting the text you want to delete.

- Release the [Cut] key. The text is deleted and placed on Clipboard. The caret remains in its original position.

To set the insertion point for the destination without losing the primary selection, use secondary Copy:

- Make a primary selection.

- Hold down the [Copy] key while setting the caret by clicking LEFT.

- Release the [Copy] key. The primary selection is copied to the left or right of the secondary selection, depending on which end you clicked nearest to. The caret moves to the end of the insertion.

Finding a Secondary Selection

To search for a secondary selection, hold down the [Find] key while selecting text. The secondary selection is searched for when you release the function key, and the first occurrence that's found is highlighted. The search is in a forward direction, but you can reverse it by holding down [Shift-Find] while selecting text. This is a handy way to search without changing the Clipboard or the current primary selection. Note that the search begins at the caret, not at the secondary selection.

Stopping a Secondary Selection

When you start a secondary operation -- for example, hold down [Paste] and select some text -- and then decide you don't want to complwete the operation, press the [Stop] key to reset the window.

NOTE: If a text window gets stuck so it makes only secondary selections, press the [Stop] key to reset the window.

[Also there is a comprehensive Table 6-2: Quick Editing with Secondary Selections, on page 109, that I won't transcribe, but you can look at in the pdf if you're interested. There's even a way to SWAP: Exchange locations of primary selection and secondary selection: Make primary selection: pending-delete; Make secondary selection: [Control-Copy] then regular [Paste].]

Now 30 some years later I finally see what all that weird and broken stuff in in SunView and XView was trying to do, and what a blatant but poorly executed copy it was. But now seeing how much better than Cedar/Mesa was than C, it's a wonder they even pulled that off. Sun's textedit seems a very far cry from Tioga, but they were so into it that the Sun keyboards had all the necessary keys for many years later. We could have had "buttonls" for all these years??

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.

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?

Actual demonstration starts at 14:30

Reply on news.ycombinator.com