A Commentary on the Sixth Edition of the Unix Operating System (1977) | Hacker News Reader

A Commentary on the Sixth Edition of the Unix Operating System (1977)

lemis.com

I was very curious how come there is a PDF from 1977. Apparently it is built from these source files: http://www.lemis.com/grog/Documentation/Lions/index.php

A fork on GitHub: https://github.com/kanner/lions-book

Ok, we've changed to that from http://www.lemis.com/grog/Documentation/Lions/book.pdf above. Thanks!

if you read kernighan's book (he was there man) about the history of unix or whatever, it's quite a lovely read and talks a lot about the motivations and origins of unix, and hopefully some new unix tools for even the experienced unixbeard. anyway, if you read that book, it's quite clear that quite a bit of effort was made at bell labs for technology related to printing and typesetting. I think it is from this for example ken thompson was famous for being like "I'm going to rewrite this firmware" in the afternoon, and knowing nothing of the architecutre or anything, had a firmware by that evening. I mean that's pretty sick speed.

I believe this book was once illegal, due to IP battles over Unix. I bought a copy of it from amazon, and the cover shows illicit photocopying in action.

https://www.amazon.ca/Lions-Commentary-Unix-John/dp/15739801...

this repo has many more versions of unix source:

https://github.com/dspinellis/unix-history-repo

I used the book, or tried to use it, to track down the original chroot code, for my own little container implementation for a talk:

https://www.youtube.com/watch?v=89ESCBzM-3Q

There is a wiki with details.

https://en.m.wikipedia.org/wiki/A_Commentary_on_the_UNIX_Ope...

It was, it only goes to proof that had AT&T been allowed to profit from UNIX, it would not have widespread as it did, especially if it had the same price tag as OSes from IBM, DEC, Wang,...

It was; it was covered by the AT&T Unix source license. I have a copy that is an actual n-th generation photocopy I got in the mid-80s from an osdev buddy.

Likewise, I still have an nᵗʰ generation photocopy I made in the mid '80s. (My employer at the time had a source license and an n-1ᵗʰ generation photocopy.)

Oh how fun! I have a copy of the modern paperback reprint of the Lyons book. But my kid is into book-binding, and I’ve always wanted a scruffy, Nth-generation photo-copy so that I could give it the full medieval-monk leather-bound treatment. Just for the absurdity of it all.

The hard part about getting an n+1ᵗʰ-generation photocopy today would be finding an actual photocopier.

There was one in the UPS store I went to last week.

You know, the more I look at the implementation of exit()/rexit()/wait(), the more I think the PID 1's job of reaping zombies is unnecessary. In exit(), instead of reparenting children to PID 1, the process could reparent them to e.g. PID 0 or PID -1, and then instead of swapping its accounting data to disk unconditionally, it could do it only if its parent's own PID is not 0 (or -1) but when it is, it would intstead do the process entry cleanup part that's in wait() on itself. This, I believe, is all that's needed to make to unparented zombie processes self-reaping.

Edit: no, it's not. During the reparenting step, the process should also clean all its zombie children and that may be a long action that involves swapping from disk; so its instead delegated to PID 1 to do it one process at a time. Well, at least now I have at least some of justification for the original design.

why do we really need zombies? isn't this just a question of making sure that the exit status is available if any one cares? and ultimately thats a separable issue from whether or not the death of a process forces the death of others.

imagine instead of wait, processes just went away, and we have..lets say a pipe that contains the single byte exit. have we lost anything important?

Congratulations, you've basically reinvented pidfd.

But notice that the Sixth Edition didn't yet have "select", so they had to invent a separate, non-fd kind of entity to track the processes and a separate syscall to both check the process status and to free the tracking entity.

A mention of Xv6 might be appropriate.

https://pdos.csail.mit.edu/6.828/2024/xv6.html

https://en.m.wikipedia.org/wiki/Xv6

Bigass thread a couple of months ago https://news.ycombinator.com/item?id=40613126

Big ass-thread?

(see: https://xkcd.com/37/)

It has often been suggested that 1,000 lines of code represents the practical limit in size for a pro- gram which is to be understood and maintained by a single individual.

This seems quite small, even without the aid of modern IDEs. Is there any evidence that such a limit exists?

(1977)

Reply on news.ycombinator.com