>Date: Tue, 28 Feb 2017 14:11:24 -0500
>From: Nemo <cym224(a)gmail.com>
>To: The Eunuchs Hysterical Society <tuhs(a)tuhs.org>
>Subject: [TUHS] Was 5ESS built on UNIX?
>Message-ID:
><CAJfiPzyDkUP7aAfxQTv51MF61a4CjKSSMxduQaW+Yp0cW00y5w(a)mail.gmail.com>
>Content-Type: text/plain; charset=UTF-8
>
>>I have looked at the papers published in the AT&T Technical J. in 1985
>and found no mention of UNIX.
>
>N.
My Prentice Hall "UNIX(R) System V Release 4, Programmer's Guide:
Streams" lists AT&T copyrights from 1984 - 1990 and UNIX Systems
Laboratories, Inc. 1991-1992.
Rudi
As Corey said, administrative computers in switching centers
ran Unix, but the call-processing machines ran an unrelated
operating system. The Unix lab did influence that operating
system. Bob Morris instigated, and Joe Condon, Lee McMahon,
Ken Thompson and others built TPC (the phone company), a switching
system controlled by a PDP-11. This system actually ran the
phones in CS Research for several years. ESS5 adopted some
of TPC's architecture, though none of its code.
Doug
Dave Horsfall:
And if my failing memory
serves me correctly, [Henry Spencer] wrote C-News in conjunction with Geoff Collier, as
B-News was starting to show its age and limitations.
====
Your failing memory is correct, except that his name is spelt
Collyer, not Collier.
Norman Wilson
Toronto ON
Hi,
On the subject of Troff, this package seems to have disappeared:
flo—A Language for Typesetting Flowcharts
Anthony P. Wolfman and Daniel M. Berry
Computer Science, Technion, Haifa 32000, ISRAEL
1989
The paper about it is available but the code has gone.
Anyone have an archive of it?
-Steve
On 2017-02-27 08:26, Lars Brinkhoff <lars(a)nocrew.org> wrote:
> Tim Bradshaw wrote:
>>> David wrote:
>>> I remember that GNU Emacs launched the first time and then dumped
>>> itself out as a core file. Each subsequent launch would then ‘undump’
>>> itself back into memory. All this because launching emacs the first
>>> time required compiling all that lisp code.
>> It still works like that. Indeed that's the conventional way that
>> Lisp systems tend to work for delivering applications
> Emacs came from ITS, and many Lisps derive from Maclisp which also came
> from ITS. In ITS, it was common for applications to be dumped into a
> loadable core image, even if they were written in assembly language.
Not only i ITS. This is how things work in OS/8, for example. I believe
it is also how things work in TOPS-10 and quite possible also in TOPS-20.
Not sure about RT-11, but I wouldn't be surprised if that's the way
there too.
Essentially, the linker leaves the image in memory. It does not write it
to a file. And then, the command decode have a command for dumping your
memory to disk, as a runable image. There is some information kept
around that the linker sets up, which means you don't normally have to
tell the command decoder which parts of memory to save, or what the
start address is, and so on. But you can also give that information in
your save command.
One of the nice things of this approach is that you can load an image
into memory, and then use the debugger to look around in it, change it,
or run it. And if the program exists, it is still in memory, including
all data, which means you can check the state of everything at exit
time. And of course, if you want to, you can load a program, patch
around in it, in memory, and then run it. And, of course, you can load a
program, run some part of it, and dump it to disk at that stage, so all
initializations have been done.
Your memory is always around, and is not tied to a process that comes
and goes.
Of course, the back side of that is that you can't really run several
programs at once.
But it's not hard to see that RMS and GNU Emacs (coming from these
systems) wanted the same thing again. It do have some points.
Johnny
--
Johnny Billquist || "I'm on a bus
|| on a psychedelic trip
email: bqt(a)softjar.se || Reading murder books
pdp is alive! || tryin' to stay hip" - B. Idol
Hmm well I am more interested in the ancient code, I am not averse to
adding improvements but I want to do so in a controlled way. Also I prefer
not to use any Sys3~5 interfaces in my current project which is exclusively
BSD.
Haha, well I de-algoled /bin/sh twice so far, first time was for my uzi to
Z180 port about 10yrs back, and second time was for my 4.3BSD to Linux
porting library project last month. In the intervening time I became quite
a sed wizard and my latest de-algolizer is completely automated and
produces very nice results. Could possibly be improved by astyle's removal
of braces around single statements, I considered this too risky at the time
but I have since realized I can compare the stripped executables to
convince myself that it does not change the logic, indeed I should check
the basic de-algolizer in this way also.
Lately I have been thinking of running all of 4.3BSD through astyle but I
hesitate to do unnecessary changes, one always regrets them when doing any
bisecting or rebasing stuff...
Nick
On Feb 28, 2017 3:43 AM, "Joerg Schilling" <schily(a)schily.net> wrote:
Derek Fawcus <dfawcus+lists-tuhs(a)employees.org> wrote:
> How about applying Geoff Collyer's change to the shell memory management
> routine available here:
>
> http://www.collyer.net/who/geoff/stak.port.c
Depends on what shell you are talking about.
The code named by you only works with a very old Bourne Shell that can be
retrieved from the server of Geoff Collyer.
If you are interested in the recent Bourne Shell (SVr4 + Solaris changes),
you
better use my Bourne Shell sources that can be found inside the
schily-tools:
http://sourceforge.net/projects/schilytools/files/
The code from above will not work in a recent Bourne Shell without changes
in
both, Geoff Collyer's stak.c and the rest of the Bourne Shell.
Jörg
--
EMail:joerg@schily.net (home) Jörg Schilling D-13353
Berlin
joerg.schilling(a)fokus.fraunhofer.de (work) Blog:
http://schily.blogspot.com/
URL: http://cdrecord.org/private/http://sourceforge.net/
projects/schilytools/files/
Ooo. Fun. We're talking PDP-10s on a Unix list... :-)
On 2017-02-27 16:13, Arthur Krewat <krewat(a)kilonet.net> wrote:
> In TOPS-10, you could detach from your current job, login again, and
> keep going. Then, attach to the previous job, and go back and forth
> endlessly.
Right. But that is a different thing. Each terminal session only have
one job. The fact that you can detach that, and log in as a new session
is a different concept.
> As for keeping memory around, it was very common on TOPS-10 to put code
> in a "hiseg" that would stick around, and was shareable between "jobs".
Yes. Again, that is a different thing as well. Hisegs are more related
to shared memory.
I assume you know all this, so I'm not going to go into details.
But having the memory around for a program, even if it is not running,
is actually sometimes very useful. If ITS could handle that, while
treating them as separate processes, all associated to one terminal, and
let you select which one you were currently fooling around in, while the
others stayed around, that is something I don't think I've seen elsewhere.
> For something like EMACS, it would be very efficient to have the first
> person run it "compile" all the LISP, leave it in the hiseg, and other
> jobs can then run that code.
That would work, but it would then require that all other users be
suspended until the first user actually completes the initialization,
and after that, all the memory must be readonly.
> Not knowing anything about EMACS, I'm not sure that compiled code was
> actually shareable if it was customized, just thinking out loud.
You can certainly customize and save your own image. But the general
bootstrapping of Emacs consists of starting up the core system, and then
loading a whole bunch of modules and configurations. All that loading
and parsing of those files into data structures in memory is quite cpu
intensive.
Once all that processing is finished, you can start editing.
Each person essentially wants all that work done, no matter what they'd
like to do later. So, Emacs does it once, and then saves the state at
the point where you can start editing.
But it does not mean that the memory is shareable. It's full of various
data structures, and code, and that will change as you go along editing
things as well.
> But even without leveraging the hiseg capability, it was relatively easy
> to save an entire core image back to a .SAV or .LOW or later a .EXE. I
> don't remember how easy it was to do that programmatically, but it was
> easy from the terminal and if it saves a lot of processor time (and
> elapsed time) people would have been happy to do it manually.
Indeed. Like I said, Tops-10 have the same concept as Emacs does today.
But there it was essentially what you always did.
Johnny
--
Johnny Billquist || "I'm on a bus
|| on a psychedelic trip
email: bqt(a)softjar.se || Reading murder books
pdp is alive! || tryin' to stay hip" - B. Idol
I ported GNU Emacs to the Celerity product line mostly because most of the programmers there wanted it over vi. Not me, I’m a vi guy.
I remember that GNU Emacs launched the first time and then dumped itself out as a core file. Each subsequent launch would then ‘undump’ itself back into memory. All this because launching emacs the first time required compiling all that lisp code.
Does anyone else remember this?
David
