I’m re-reading Brian Kernighan’s book on Early Unix (‘Unix: A History & Memoir’)
and he mentions the (on disk) documentation that came with Unix - something that made it stand out, even for some decades.
Doug McIlroy has commented on v2-v3 (1972-73?) being an extremely productive year for Ken & Dennis.
But as well, they wrote papers and man pages, probably more.
I’ve never heard anyone mention keyboard skills with the people of the CSRC - doesn’t anyone know?
There’s at least one Internet meme that highly productive coders necessarily have good keyboard skills,
which leads to also producing documentation or, at least, not avoiding it entirely, as often happens commercially.
Underlying this is something I once caught as a random comment:
The commonality of skills between Writing & Coding.
Does anyone has any good refs for this crossover?
Is it a real effect or a biased view.
That great programmers are also “good writers”:
takes time & focus, clarity of vision, deliberate intent and many revisions, chopping away the cruft that’s isn’t “the thing” and “polishing”, not rushing it out the door.
Ken is famous for his brevity and succinct statements.
Not sure if that’s a personal preference, a mastered skill or “economy in everything”.
steve j
=========
A Research UNIX Reader: Annotated Excerpts from the Programmer's Manual, 1971-1986
M.D. McIlroy
<https://www.cs.dartmouth.edu/~doug/reader.pdf>
<https://archive.org/details/a_research_unix_reader/page/n13/mode/2up>
pg 10
3.4. Languages
CC (v2 page 52)
V2 saw a burst of languages:
a new TMG,
a B that worked in both core-resident and software-paged versions,
the completion of Fortran IV (Thompson and Ritchie), and
Ritchie's first C, conceived as B with data types.
In that furiously productive year Thompson and Ritchie together
wrote and debugged about
100,000 lines of production code.
=========
Programming's Dirtiest Little Secret
Wednesday, September 10, 2008
<http://steve-yegge.blogspot.com/2008/09/programmings-dirtiest-little-secret…>
It's just simple arithmetic. If you spend more time hammering out code, then in order to keep up, you need to spend less time doing something else.
But when it comes to programming, there are only so many things you can sacrifice!
You can cut down on your documentation.
You can cut down on commenting your code.
You can cut down on email conversations and
participation in online discussions, preferring group discussions and hallway conversations.
And... well, that's about it.
So guess what non-touch-typists sacrifice?
All of it, man.
They sacrifice all of it.
Touch typists can spot an illtyperate programmer from a mile away.
They don't even have to be in the same room.
For starters, non-typists are almost invisible.
They don't leave a footprint in our online community.
=========
--
Steve Jenkin, IT Systems and Design
0412 786 915 (+61 412 786 915)
PO Box 38, Kippax ACT 2615, AUSTRALIA
mailto:sjenkin@canb.auug.org.au http://members.tip.net.au/~sjenkin
The discussion about the 3B2 triggered another question in my head: what were the earliest multi-processor versions of Unix and how did they relate?
My current understanding is that the earliest one is a dual-CPU VAX system with a modified 4BSD done at Purdue. This would have been late 1981, early 1982. I think one CPU was acting as master and had exclusive kernel access, the other CPU would only run user mode code.
Then I understand that Keith Kelleman spent a lot of effort to make Unix run on the 3B2 in a SMP setup, essentially going through the source and finding all critical sections and surrounding those with spinlocks. This would be around 1983, and became part of SVr3. I suppose that the “spl()” calls only protected critical sections that were shared between the main thread and interrupt sequences, so that a manual review was necessary to consider each kernel data structure for parallel access issues in the case of 2 CPU’s.
Any other notable work in this area prior to 1985?
How was the SMP implementation in SVr3 judged back in its day?
Paul
Greetings,
What's the canonical source for patches to 2.9BSD and 2.11BSD?
I see we have 2.11BSD patch 469 dated last month in the archive. Where does
it come from? Has anybody climbed the hill to import all the patches into a
git repo? I've found some mirrors, but moe.2bsd.org has been down for me
for ages... How does Warren keep things up to date?
I also have a (maybe faulty) memory of a similar series of patches to
2.9BSD because it was the last BSD to support non-split I&D space machines.
yet a quick google search turns up nothing other than a set of patches
dated August 1985 (also in our archive) and some changes for variants of
hardware (pro, mscp). Is that it?
Warner
All,
If you think unix ends without x, just move along, nothing to see here.
Otherwise, I thought I would share the subject of my latest post and a
link with those of you interested in such things.
Recently, I've been tooling around trying to wrap my head around x
windows and wanted to give programming it a shot at the xlib level... on
my mac, if possible. So, I bought a copy of Adrian Nye's Xlib
Programming Manual for Version 11 R4/R5, aka Volume One of The
Definitive Guides to the X Window System, published, get this... 30+
years ago, in 1992 :) and started reading like a madman. As usual, this
was an example of great technical writing from the prior millenium,
something rarely found today.
Anyway, I hunted up the source code examples as published, unpacked
them, did a few environmental things to my mac, and built my first xlib
application from that source. A few tweaks to my XQuartz configuration
and I was running the application in twm on my mac, with a root window.
To read about it and see it in all of its glory, check it out here:
https://decuser.github.io/operating-systems/mojave/x-windows/2023/01/24/x-w…
The same sort of setup works with Linux, FreeBSD, or my latest
environment DragonFly BSD. It's not the environment that I find
interesting, but rather the X Window System itself, but this is my way
of entering into that world. If you are interested in running X Windows,
not as an integrated system on your mac (where x apps run in aqua
windows), but with a 'regular' window manager, and you haven't figured
out how, this is one way.
On the provocateur front - is X part of unix? I mean this in oh so many
nuanced ways, so read into it as you will. I would contend, torpedoes be
damned, that it is :).
Will
Herewith some interesting (somewhat) contemporary papers on early windowing systems:
1. There was a conference in the UK early in 1985 discussing the state of window systems on Unix. Much interesting discussion and two talks by James Gosling, one about NeWS (then still called SunDew), and one about what seems to be SunWindows. It would seem then that these were developed almost in parallel.
http://www.chilton-computing.org.uk/inf/literature/books/wm/contents.htm
2. Then there is a 1986 paper by James Gettys, discussing the 18 month journey towards X10. In particular it focuses on the constraints that Unix set on the design of the X system.
https://www.tech-insider.org/unix/research/acrobat/860201-b.pdf
3. Next is the 1989 NeWS book that has a nice overview and history of windowing systems in its chapter 3:
http://bitsavers.trailing-edge.com/pdf/sun/NeWS/The_NeWS_Book_1989.pdf
Both the UK conference and the NeWS book mention a Unix kernel-based windowing system done at MIT in 1981 or 1982, “NU" or “NUnix”, by Jack Test. That one had not been mentioned before here and may have been the first graphical windowing work on Unix, preceding the Blit. Who remembers this one?
4. Finally, an undated paper by Stephen Uhler discussing the design of MGR is here:
https://sau.homeip.net/papers/arch.pdf
I’ve not included Rob Pike’s papers, as I assume they are well known on this list.
Some of the above papers may be worthy of stable archiving.
I did not want to disrupt the FD 2 discussion, but I could not really let
this comment go unanswered:
"Smells like C++ to me. Rust in essence is a re-implementation of C++ not
C. It tries to pack as much features as it possibly can. "
It's hard for me to see how you can say this if you have done any work in
Rust and C++.
But, short form: Rust is not C++. Full stop.
I did not feel that comment should go unanswered, lest people believe it.
Hello!
I saw someone playing chess on their pdp-11 and thought it could be an
interesting project to run on my pdp-11. At this point the RK05s are not
yet running so booting unix v6 is not possible.
I then thought that if the source code could be found it might be possible
to get it to run standalone with some modifications.
After some googling I found the archive
https://www.tuhs.org/Archive/Distributions/UNSW/7/record0.tar.gz
which contained a chess.lib file. It appeared that this archive contained
source code for some kind of chess program. I have been told that it isn't
the chess written by Ken Thompson so the question is who wrote it? There
are not many comments in the code. Could be interesting to know more about
this chess implementation.
Just looking through the source files and the mk file show that it is
missing a set of files. The mk file references a set of "b"-prefixed
assembly files, bgen.s, bmove.s, bheur.s and bplay.s which are present in
the archive. But it also references a set of files with "w"-prefix, wgen.s,
wmove.s, wheur.s and wplay.s which are missing.
I also recognise that there is an include file, "old.h" that is included
from all c-modules that most likely is present in the overload.lib which
seems to be an overlay loader.
Anyone that has an idea how this thing was built once upon a time?
/Mattis
A lot of this dates back from the old “tty” days (or at least crt
terminals that were still alphanumeric). Even the concept of putting
a job in the background with & is really a feature of trying to
multiplex multiple tasks on the same dumb terminal. This is indeed
less important with windowing things like the DMDs or modern windowing
workstatiosn when you can just get another window. The Berkeley job
control was an interesting hack. For us at BRL the problem was I
absolutely detested the C shell syntax. The Korn shell hadn’t escaped
from AT&T yet, so, I spent time figuring out how that really worked in
the C shell (not really well documented), mostly by inspection, and then
reimplemented it in the Bourne Shell (we were using the System V source
code version for that). I still couldn’t get traction at BRL for
using the Bourne shell because by that time, tcsh had come out with
command line editing. So back to the shell sources I went. By this
time, 5R2 had come out so I grabbed the shell source form that. I was
very delighted to find that the macros that made C look sorta like Algol
had been unwound and the thing was back to straight C. I reworked
emacs-ish command line editing into the shell. Subsequently, I had a
nice conversation with David Korn at USENIX, being probably at that
point the two most familiar with Bourne shell job control internals. I
also sat down with the guys writing either bash or the pdksh (can’t
remember which) and explained all how this work. As a result my name
ended up in the Linux manpages which was pretty much all I found for a
while when I googled myself.
Years later, I had left the BRL, spent three years as a Rutgers
administrator and was working for a small startup in Virginia. There
was a MIPS workstation there. I was slogging along using ed (my
employees always were amazed that if there was no emacs on the system, I
just used ed, having never learned vi). Not thinking about it, I
attempted to retrieve a backgrounded job by typing “fg.” To my
surprise the shell printed “Job control not enabled.” Hmm, I say.
That sounds like my error message. “set -J” I type. “Job control
enabled.” Hey! This is my shell. Turns out Doug Gwyn put my mods
into his “System V on BSD” distribution tape and it had made its way
into the Mach code base and so every Mach-derived system ended up with
it. Certainly, I found it convenient.
There have been other schemes other than job control to multiplex
terminals. IBM in the AIX that ran on the 370/PS2/i860 had a device
called the High Function Terminal that allowed you to swap screens on
the console. When we implemented the i860 (which was an add in card
for the micro channel), we called our console the Low Function Terminal.
Then after spending some time on MIT’s ITS and TOPS20, I got intrigued
by the fact on those systems you could have a “shell” that persisted
across logins and could be detached and reattached on another device at
another time. I set about making such an implementation. Not
particularly efficient, it essentially grabbed one of the BSD ptys and
spawned the shell there and then a small alternative login shell
forwarded the real tty to that. You could then detach it leaving the
shell running on the PTY and reattach it elsewhere. Much like ITS,
on. login it reminded you that you had a detached shell running and
offered to reattach it rather than spawning a new one (complete with the
ITS-ish: space for yes, rubout for no). It never really caught on.
Oh well, pardon my ramblings.
-Ron
