Hello all,
I found a reference to a port of the MIT ChaosNet code to Linux on:
http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
latter is defunct. Does someone know how to get this code?
Andreas
Andreas Holz wrote:
> Hello all,
>
> I found a reference to a port of the MIT ChaosNet code to Linux on:
> http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
> latter is defunct. Does someone know how to get this code?
>
> Andreas
Does anyone know _why_ they used 36-bit words??? Why not 2^n? (Or say 2^5 -
1, like O'Caml's integer?)
Oleg
--
"It's because they're stupid, that's why. That's why
everybody does everything." -- Homer Simpson.
Oleg <············@myrealbox.com> writes:
> Andreas Holz wrote:
>
> > Hello all,
> >
> > I found a reference to a port of the MIT ChaosNet code to Linux on:
> > http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
> > latter is defunct. Does someone know how to get this code?
> >
> > Andreas
>
> Does anyone know _why_ they used 36-bit words??? Why not 2^n? (Or say 2^5 -
> 1, like O'Caml's integer?)
Because the PDP-10 had 36-bit words (and an 18-bit address space).
That's just the way it was. The predecessor to the -10s, the PDP-6,
was also a 36/18 bit machine. Such hardware dates back to the days
before the 8 bit byte was 'standardized'. 36-bit systems typically
used 6-bit bytes for simple printable characters, called SIXBIT ASCII
or simply SIXBIT. Or ASCIZ??
The great thing about the 10s was that they had an 18 bit address
space but a 36 bit word. So one word could hold two pointers. It was
tailor made for a CONS cell. This was the main reason (amongst a few
others) why the architecture was so attractive to Lisp developers.
But the small size of the 18-bit address space became a problem as
programs grew, even with high moby core (18+1 bits).
The MIT Lisp Machines were 32-bit however. 28 bits of address and 4
bits of type tag and cdr code. Remember that this was at a time when
your average Personal Computer was 8-bits max!!! And LispMs were
billed as PCs! The LMI LAMBDA and TI Explorers were the same. The
Symbolics 36xx series, in the spirit of PDP-10s, had its wordsize
grown to 36 bits, with 32 bits of address and 4 bits of type tag and
cdr code. Later the introduction of the Ivory processor increased
this to a 40 bit word.
Even most modern Lisps today use a couple of bits of type tag,
typically two. So your 32-bit Lisp probably can only handle 30-bit
fixnums. More than that and it conses you up a bignum. But you don't
see that (you might still see it in the desert), because Lisp is so
nice that it doesn't mention it to you (except of course for CMUCL's
Python, which harangues you about the high cost of bignum addition and
complains about how you never call anymore...).
The reason that 8 bits per byte caught on was because of the influence
of 8-bit microprocessors like the Intel 4004 series. Those were in
turn influenced by IBM's 360 architecture which also used 8-bit bytes.
There are other reasons as well. If you want a full explanation then
ask the question on alt.folklore.computers, where all the *really*
crufty old farts hang out... ^_^
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
"James A. Crippen" <·····@unlambda.com> wrote in message ···················@kappa.unlambda.com...
>
> The MIT Lisp Machines were 32-bit however. 28 bits of address and 4
> bits of type tag and cdr code.
The MIT CADR, the LMI CADR and Symbolics CADR had 2 bits of
CDR codes, 6 bits of tags and 24 bit word addresses.
The LMI Lambda and the TI Explorer I had 2 bits of CDR codes 5 bits of tags
and 25 bit word addresses.
The LMI K had no CDR codes, 6 bits of tags and 26 bit word addresses.
> Remember that this was at a time when
> your average Personal Computer was 8-bits max!!! And LispMs were
> billed as PCs!
A big PC might have as much as 32K of RAM, but that often required
peripheral hardware. The CADRs had something like 192K in some
configurations. The Lambdas I think had up to 4 meg.
"Joe Marshall" <·············@attbi.com> writes:
> "James A. Crippen" <·····@unlambda.com> wrote in message ···················@kappa.unlambda.com...
> >
> > The MIT Lisp Machines were 32-bit however. 28 bits of address and 4
> > bits of type tag and cdr code.
>
> The MIT CADR, the LMI CADR and Symbolics CADR had 2 bits of
> CDR codes, 6 bits of tags and 24 bit word addresses.
>
> The LMI Lambda and the TI Explorer I had 2 bits of CDR codes 5 bits of tags
> and 25 bit word addresses.
>
> The LMI K had no CDR codes, 6 bits of tags and 26 bit word addresses.
That's right... I don't know where I got 28 bits from... Maybe some
other Lisp implementation?
> > Remember that this was at a time when
> > your average Personal Computer was 8-bits max!!! And LispMs were
> > billed as PCs!
>
> A big PC might have as much as 32K of RAM, but that often required
> peripheral hardware. The CADRs had something like 192K in some
> configurations. The Lambdas I think had up to 4 meg.
Exploders had typically 32MB near the end of their manufacture. You
could get 128MB in them though, but you wouldn't have room for many
other cards.
The neat thing about the Exploders was that it was possible (though
not common) to do SMP with them. It was allowed to have more than one
processor board installed in the system. They could share memory
too. I think only one installation ever actually did real SMP with
Exploders, though.
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
·····@unlambda.com (James A. Crippen) writes:
> The neat thing about the Exploders was that it was possible (though
> not common) to do SMP with them. It was allowed to have more than one
> processor board installed in the system. They could share memory
> too. I think only one installation ever actually did real SMP with
> Exploders, though.
There was no such thing as SMP for the Explorer. There was an
Explorer MP configuration, which was a menagerie of CPU cards stuffed
into an extra large Explorer LX chassis running separate system images
(that allegedly could communicate with each other over the backplane
using shared memory). While this is a neat hack, it does not qualify
as symmetric multi-processing.
In case anybody is interested, John Koza's first "Genetic Programming"
describes one application of a multi-processor Explorer.
"Joe Marshall" <·············@attbi.com> wrote in message
···························@sccrnsc02...
>
> "James A. Crippen" <·····@unlambda.com> wrote in message
···················@kappa.unlambda.com...
> >
> > The MIT Lisp Machines were 32-bit however. 28 bits of address and 4
> > bits of type tag and cdr code.
>
> The MIT CADR, the LMI CADR and Symbolics CADR had 2 bits of
> CDR codes, 6 bits of tags and 24 bit word addresses.
>
> The LMI Lambda and the TI Explorer I had 2 bits of CDR codes 5 bits of
tags
> and 25 bit word addresses.
>
> The LMI K had no CDR codes, 6 bits of tags and 26 bit word addresses.
>
> > Remember that this was at a time when
> > your average Personal Computer was 8-bits max!!! And LispMs were
> > billed as PCs!
>
> A big PC might have as much as 32K of RAM, but that often required
> peripheral hardware. The CADRs had something like 192K in some
> configurations. The Lambdas I think had up to 4 meg.
That's a bit of a stretch; I had an S-100 bus machine in 1979 (i.e. like an
Altair, though I had a Z-80 and which predates the LispM) with 64K of memory
(dynamic) later extended using an i/o port and a latch to have 4 banks of
48K with 16K in common in each bank (so I could run MP/M, the multiuser
version of Digital Research's CP/M, the predecessor to the M$ DOS clone).
"James A. Crippen" wrote:
> Such hardware dates back to the days
> before the 8 bit byte was 'standardized'. 36-bit systems typically
> used 6-bit bytes for simple printable characters, called SIXBIT ASCII
> or simply SIXBIT. Or ASCIZ??
While this may have been typical somewhere, it wasn't the only way. The
school I went in ran their PDP-10 with 7-bit characters, and I believe
some people (SAIL ?) ran them with 9-bit characters. The machine allowed
any length of bytes to be used, I believe.
--
Martti Halminen <···············@kolumbus.fi> writes:
> "James A. Crippen" wrote:
>
> > Such hardware dates back to the days
> > before the 8 bit byte was 'standardized'. 36-bit systems typically
> > used 6-bit bytes for simple printable characters, called SIXBIT ASCII
> > or simply SIXBIT. Or ASCIZ??
>
> While this may have been typical somewhere, it wasn't the only way. The
> school I went in ran their PDP-10 with 7-bit characters, and I believe
Really? 7 bit? That doesn't fit very well into a 36 bit word... I
know it was supported in most systems for ASCII obviously, but didn't
think that it would be used internally in whatever OS was running...
What do you put in the other 0.142857142857...th of the word once
you've stuffed in the five 7-bit characters? Maybe a parity bit?
> some people (SAIL ?) ran them with 9-bit characters. The machine allowed
SAIL used 9-bit chars in WAITS, IIRC.
> any length of bytes to be used, I believe.
As I mentioned in another post, ITS also had its 12-bit characters for
full support of the space-cadet keyboard. This was supported in
SUPDUP, naturally.
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
In article <··············@kappa.unlambda.com>,
James A. Crippen <·····@unlambda.com> wrote:
>Martti Halminen <···············@kolumbus.fi> writes:
>
>> "James A. Crippen" wrote:
>>
>> > Such hardware dates back to the days
>> > before the 8 bit byte was 'standardized'. 36-bit systems typically
>> > used 6-bit bytes for simple printable characters, called SIXBIT ASCII
>> > or simply SIXBIT. Or ASCIZ??
>>
>> While this may have been typical somewhere, it wasn't the only way. The
>> school I went in ran their PDP-10 with 7-bit characters, and I believe
>
>Really? 7 bit? That doesn't fit very well into a 36 bit word... I
>know it was supported in most systems for ASCII obviously, but didn't
>think that it would be used internally in whatever OS was running...
Once ASCII became the standard character set, you were pretty much forced
to use at least 7 bits. 6-bit ASCII is only usable if you're willing to
forego lowercase. I think it was used in directory files (the filename and
filetype were each a single word, allowing each component to be up to 6
monocase characters), but file contents were generally 7-bit ASCII.
BTW, I think ASCIZ means "ASCII with Zero-byte terminator", a la C strings.
>What do you put in the other 0.142857142857...th of the word once
>you've stuffed in the five 7-bit characters? Maybe a parity bit?
It's ignored. The PDP-10 byte operations handle this automatically for
you.
>> some people (SAIL ?) ran them with 9-bit characters. The machine allowed
>
>SAIL used 9-bit chars in WAITS, IIRC.
Multics, another 36-bit system, also used 9-bit characters. But since
ASCII was only 7 bits, this wasted much more than ITS's 7-bit characters: 2
bits/character versus 7 bits/5 characters, or 25% more words used to hold
the same number of characters. In the days when memory (both physical and
virtual) was extremely expensive, this could make a big difference.
However, systems that used 8- or 9-bit characters could sometimes make use
of those extra bits. It wasn't uncommon for simple parsers to use them as
flags to show where token boundaries are (I think early versions of the
Unix Bourne shell did this with the 8th bit, but it had to be removed when
systems started to support the 8-bit, international extensions to ASCII).
>> any length of bytes to be used, I believe.
>
>As I mentioned in another post, ITS also had its 12-bit characters for
>full support of the space-cadet keyboard. This was supported in
>SUPDUP, naturally.
I don't think these were every stored in files, they were only used in
communications.
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
* Barry Margolin
| Once ASCII became the standard character set, you were pretty much forced
| to use at least 7 bits.
As far as I can see from the historical record, DEC always used 7-bit ASCII
on their PDP-10 series operating systems. I have no record of PDP-6 systems.
| 6-bit ASCII is only usable if you're willing to forego lowercase.
Actually, there is no such thing as 6-bit ASCII. SIXBIT has no control codes
and is completely useless except in extremely well-controlled settings.
There is no support for printing or typing SIXBIT files, for instance -- if
files were opened with 6-bit bytes, they would appear to contain 32 control
codes and the first 32 non-letter ASCII character -- hardly useful. (Yes, I
have tried this, back in the summer of 1980, wasting huge amounts of paper
due to the unfortunate placement of certain control codes.)
| I think it was used in directory files (the filename and filetype were each a
| single word, allowing each component to be up to 6 monocase characters), but
| file contents were generally 7-bit ASCII.
At least under TOPS-10, the right half of the file type word was used for the
CFP (compressed file pointer) into the RIB (retrieval information block) in
the UFD (user-file directory) or SFD (sub-file directory), so you could have
only three letters in the file type, but six in the file name, thus a
directory entry was formed by two machine words. (For completeness, the UFD
was itself a file with extension .UFD in the MFD (master file directory.))
[All according to my trusty old TOPS-10 Monitor Calls Manual, Volume 1, from
February 1984.]
| BTW, I think ASCIZ means "ASCII with Zero-byte terminator", a la C strings.
Correct.
| Multics, another 36-bit system, also used 9-bit characters. But since
| ASCII was only 7 bits, this wasted much more than ITS's 7-bit characters: 2
| bits/character versus 7 bits/5 characters, or 25% more words used to hold
| the same number of characters. In the days when memory (both physical and
| virtual) was extremely expensive, this could make a big difference.
I did not follow that computation, but the number of words to hold a file of
9-bit characters (four to a word) compared to 7-bit characters (five to a
word) would indeed be (/ 1/4 1/5) => 5/4 or 25% more.
--
Guide to non-spammers: If you want to send me a business proposal, please be
specific and do not put "business proposal" in the Subject header. If it is
urgent, do not use the word "urgent". If you need an immediate answer, give
me a reason, do not shout "for your immediate attention". Thank you.
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
>* Barry Margolin
>| Once ASCII became the standard character set, you were pretty much forced
>| to use at least 7 bits.
>
> As far as I can see from the historical record, DEC always used 7-bit ASCII
> on their PDP-10 series operating systems. I have no record of PDP-6 systems.
I don't know much about what DEC did, as much of my PDP-10 experience was
on ITS, which did not come from DEC. There was quite a bit of 6-bit in ITS.
>| 6-bit ASCII is only usable if you're willing to forego lowercase.
>
> Actually, there is no such thing as 6-bit ASCII. SIXBIT has no control codes
> and is completely useless except in extremely well-controlled settings.
You're right, it's wrong to call it ASCII, it's just a 6-bit character set
(wasn't BAUDOT also a 6-bit character set)?
>| I think it was used in directory files (the filename and filetype were each a
>| single word, allowing each component to be up to 6 monocase characters), but
>| file contents were generally 7-bit ASCII.
>
> At least under TOPS-10, the right half of the file type word was used for the
> CFP (compressed file pointer) into the RIB (retrieval information block) in
> the UFD (user-file directory) or SFD (sub-file directory), so you could have
> only three letters in the file type, but six in the file name, thus a
> directory entry was formed by two machine words. (For completeness, the UFD
> was itself a file with extension .UFD in the MFD (master file directory.))
> [All according to my trusty old TOPS-10 Monitor Calls Manual, Volume 1, from
> February 1984.]
I was still talking about ITS.
>| BTW, I think ASCIZ means "ASCII with Zero-byte terminator", a la C strings.
>
> Correct.
>
>| Multics, another 36-bit system, also used 9-bit characters. But since
>| ASCII was only 7 bits, this wasted much more than ITS's 7-bit characters: 2
>| bits/character versus 7 bits/5 characters, or 25% more words used to hold
>| the same number of characters. In the days when memory (both physical and
>| virtual) was extremely expensive, this could make a big difference.
>
> I did not follow that computation, but the number of words to hold a file of
> 9-bit characters (four to a word) compared to 7-bit characters (five to a
> word) would indeed be (/ 1/4 1/5) => 5/4 or 25% more.
I worded it badly -- I didn't mean to imply that I got that result from
that computation, just that they were two ways of looking at the wastage.
I got my 25% result the same way you did. It came out the way it did
because I did the latter computation after having already written the
sentence about bits per character.
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
"Barry Margolin" <······@genuity.net> wrote in message
····················@paloalto-snr1.gtei.net...
> In article <················@naggum.net>, Erik Naggum <····@naggum.net>
wrote:
> >* Barry Margolin
> >| Once ASCII became the standard character set, you were pretty much
forced
> >| to use at least 7 bits.
> >
> > As far as I can see from the historical record, DEC always used 7-bit
ASCII
> > on their PDP-10 series operating systems. I have no record of PDP-6
systems.
>
> I don't know much about what DEC did, as much of my PDP-10 experience was
> on ITS, which did not come from DEC. There was quite a bit of 6-bit in
ITS.
The CDC Cyber systems used 6-Bit, all crammed into a 60-bit word. As I
recall, lowercase was "escaped" with a preceding ^. T^H^I^S ^I^S
^L^O^W^E^R^C^A^S^E. (Unix did it backward, as I recall, escaping the
uppercase letters).
It was quite fascinating to churn out 100's of pages of worthless output
when you printed an "ASCII" document, but not in ASCII mode.
> >| 6-bit ASCII is only usable if you're willing to forego lowercase.
> >
> > Actually, there is no such thing as 6-bit ASCII. SIXBIT has no control
codes
> > and is completely useless except in extremely well-controlled settings.
>
> You're right, it's wrong to call it ASCII, it's just a 6-bit character set
> (wasn't BAUDOT also a 6-bit character set)?
BAUDOT was 5-bit.
Ob Lisp content: On the Cyber, their Lisp used the character ']' to "close
all open parens". I can appreciate how that can save typing, particularly on
a 70's era batch system, but I think for me it would cause more trouble than
it would save.
(define func (x)
(let (z 0)
(dotimes (i 5 z)
(setf z (+ z (* x i]
Ob Lisp/Cyber/6-bit content: I recall distinctly printing out the Lisp
documentation, and forgetting the ASCII flag on the print job...oops.
Best Regards,
Will Hartung
(·····@msoft.com)
In article <············@news5.nntpserver.com>,
Will Hartung <·····@msoft.com> wrote:
>> You're right, it's wrong to call it ASCII, it's just a 6-bit character set
>> (wasn't BAUDOT also a 6-bit character set)?
>
>BAUDOT was 5-bit.
That's what I thought. But 5 bits isn't enough for 26 letters and 10
digits, so I decided my memory must have been faulty. Did it use an
escaping mechanism?
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
"Barry Margolin" <······@genuity.net> wrote in message ······················@paloalto-snr1.gtei.net...
> In article <············@news5.nntpserver.com>,
> Will Hartung <·····@msoft.com> wrote:
> >> You're right, it's wrong to call it ASCII, it's just a 6-bit character set
> >> (wasn't BAUDOT also a 6-bit character set)?
> >
> >BAUDOT was 5-bit.
>
> That's what I thought. But 5 bits isn't enough for 26 letters and 10
> digits, so I decided my memory must have been faulty. Did it use an
> escaping mechanism?
It had a shift-in/out mechanism.
Once I was up at the Ham Radio Club at Walker Memorial and they were
hacking with an old Baudot teletype. The decoder looked a bit like
an automobile distributor. There was a rotor with an arm and it
swept a over a circle of contacts. When the signal was high, it
would complete the circuit and throw a solenoid that moved a metal
bar back and forth. There were five metal bars and each had notches
cut in them in strategic places. The notches were cut so that only
one set of notches lined up for any of the 32 possible positions
of the sets of bars. Once the bars were set, a level dropped into
the correct notch and caused the appropriate key to be struck.
It was quite a sight to behold.
I wish I could remember how it synchronized with the signal.
I do remember it would occasionally drop or munge a byte. This
was in general ok unless it was a shift-in/shift-out byte, then
you had to retransmit a good chunk of the message.
* Barry Margolin
| I don't know much about what DEC did, as much of my PDP-10 experience was
| on ITS, which did not come from DEC. There was quite a bit of 6-bit in ITS.
Oh, sorry, I missed the ITS-exclusive context. I have only worked with
TOPS-10 and TOPS-20.
| You're right, it's wrong to call it ASCII, it's just a 6-bit character set
| (wasn't BAUDOT also a 6-bit character set)?
Baudot code was a telegraph alphabet using 5 bits with two shift states,
allowing 90 different characters. (Only one shift state was allowed at a
time, or 60 more characters could easily have been added, as their order
would also have mattered.) I believe Baudot was International Telegraph
Alphabet Number 1, but cannot confirm this now. It dates back to 1880, and
was replaced by the start-stop asynchronous International Telegraph Alphabet
Number 2, about which I find no authoritative information -- my library of
past editions of the CCITT colored books are not that complete. (And after
having tried to explain the relationship between Unicode and ISO 6429 to a
few people and having been voted down by Google searches because the myths
outnumber the actual specification, I have once again lost all faith in
asking the Internet in general for accurate and correct information.)
--
Guide to non-spammers: If you want to send me a business proposal, please be
specific and do not put "business proposal" in the Subject header. If it is
urgent, do not use the word "urgent". If you need an immediate answer, give
me a reason, do not shout "for your immediate attention". Thank you.
"Erik Naggum" <····@naggum.net> wrote in message ·····················@naggum.net...
> (And after
> having tried to explain the relationship between Unicode and ISO 6429 to a
> few people and having been voted down by Google searches because the myths
> outnumber the actual specification, I have once again lost all faith in
> asking the Internet in general for accurate and correct information.)
I just love it when the democratic spirit moves people to vote
on reality.
From: Hartmann Schaffer
Subject: Re: MIT ChaosNet code port to Linux
Date:
Message-ID: <3d13de80@news.sentex.net>
In article <················@naggum.net>,
Erik Naggum <····@naggum.net> writes:
> ...
> Baudot code was a telegraph alphabet using 5 bits with two shift states,
> allowing 90 different characters.
two shift states? in which context? i started out on machines whose
only input devices were 5 channel paper tape, and the software on both
systems recognized only two shift states, with one patter having the
same interpretation (space/blank) in both states
hs
--
don't use malice as an explanation when stupidity suffices
Hartmann Schaffer wrote:
>
> In article <················@naggum.net>,
> Erik Naggum <····@naggum.net> writes:
> > ...
> > Baudot code was a telegraph alphabet using 5 bits with two shift states,
> > allowing 90 different characters.
>
> two shift states? in which context? i started out on machines whose
> only input devices were 5 channel paper tape, and the software on both
> systems recognized only two shift states, with one patter having the
> same interpretation (space/blank) in both states
There were 5 patterns that had meanings independent of the shift state:
letters, figures, space, carriage return, and line feed.
In article <················@mail.ptd.net>, "T.M. Sommers" <····@mail.ptd.net>
writes:
>Hartmann Schaffer wrote:
>>
>> In article <················@naggum.net>,
>> Erik Naggum <····@naggum.net> writes:
>> > ...
>> > Baudot code was a telegraph alphabet using 5 bits with two shift
>states,
>> > allowing 90 different characters.
>>
>> two shift states? in which context? i started out on machines whose
>> only input devices were 5 channel paper tape, and the software on both
>> systems recognized only two shift states, with one patter having the
>> same interpretation (space/blank) in both states
>
>There were 5 patterns that had meanings independent of the shift state:
>letters, figures, space, carriage return, and line feed.
>
Are the 2 shift states here the most successful instance of trinary computing?
AFICT 5 bits and 2 'shift states' is equivalent to 5 bits and 1 trit.
-- Attaining and helping others attain "Aha!" experiences, as satisfying as
attaining and helping others attain orgasms.
* ········@aol.comNOSPAM (Dvd Avins)
| Are the 2 shift states here the most successful instance of trinary computing?
| AFICT 5 bits and 2 'shift states' is equivalent to 5 bits and 1 trit.
Huh? 1 bit gives you two shift states if the system is capable of shifting,
which we have to assume once we say "shift state" to begin with. Two _codes_
were used to select state. Letter shift and figures shift. Now, two _codes_
could have been two independent bits, right? That would have given a lot
more codes, but since there were only two states, you have a space of a total
of 60 codes. (I think I write 90 up there somewhere, a bad thinko.) If you
could combine the two codes (two orthogonal shift codes), things would have
been much more powerful, but that was not the case.
--
Guide to non-spammers: If you want to send me a business proposal, please be
specific and do not put "business proposal" in the Subject header. If it is
urgent, do not use the word "urgent". If you need an immediate answer, give
me a reason, do not shout "for your immediate attention". Thank you.
In article <················@naggum.net>, Erik Naggum <····@naggum.net> writes:
>* ········@aol.comNOSPAM (Dvd Avins)
>| Are the 2 shift states here the most successful instance of trinary
>computing?
>| AFICT 5 bits and 2 'shift states' is equivalent to 5 bits and 1 trit.
>
> Huh? 1 bit gives you two shift states if the system is capable of
>shifting,
> which we have to assume once we say "shift state" to begin with. Two
>_codes_
> were used to select state. Letter shift and figures shift. Now, two
>_codes_
> could have been two independent bits, right? That would have given a lot
> more codes, but since there were only two states, you have a space of a
>total
> of 60 codes. (I think I write 90 up there somewhere, a bad thinko.) If
>you
> could combine the two codes (two orthogonal shift codes), things would have
> been much more powerful, but that was not the case.
Sorry. I thought you (or somebody) had meant a base state plus two additional
shift states.
-- Attaining and helping others attain "Aha!" experiences, as satisfying as
attaining and helping others attain orgasms.
From: Tim Bradshaw
Subject: Re: MIT ChaosNet code port to Linux
Date:
Message-ID: <ey31yb0a7c1.fsf@cley.com>
* Barry Margolin wrote:
> You're right, it's wrong to call it ASCII, it's just a 6-bit character set
> (wasn't BAUDOT also a 6-bit character set)?
5 bit. No case, and there was a shift to get from the characters set
to the figures set (which had numbers).
--tim
Barry Margolin <······@genuity.net> wrote:
+---------------
| Erik Naggum <····@naggum.net> wrote:
| >| 6-bit ASCII is only usable if you're willing to forego lowercase.
| >
| > Actually, there is no such thing as 6-bit ASCII. SIXBIT has no
| > control codes and is completely useless except in extremely
| > well-controlled settings.
|
| You're right, it's wrong to call it ASCII, it's just a 6-bit character set
+---------------
"Right" or "wrong", DEC SIXBIT (mandated for filenames in PDP-10 system
calls [UUOs], among other things) *was* a strict subset of 7-bit ASCII,
with one bit inverted. Or to say it another way, the 7-bit ASCII characters
at codepoints #o40 through #o137 *were* the SIXBIT characters with values
0 through #o77.
To convert from ASCII to SIXBIT, you first upcased any alphabetics, then
complemented the #x20 (#o40) bit, and the low six bits of the result was
your SIXBIT character. In C, it would probably be something gross like:
char6 = (((char7 < 0140) ? char7 : (char7 - 040)) ^ 040) & 077;
If memory serves, it was only three lines of PDP-10 assembler, using
those wonderful combined test-under-mask-and-modify-and-conditionally-skip
instructions:
; here with a 7-bit ASCII character in t0
TRZE t0, 100 ; if alpha (and clear 7th bit unconditionally)
TRZ t0, 40 ; upcase (zero) it
TRC t0, 40 ; and in either case, complement
; t0 now has the corresponding SIXBIT char
-Rob
-----
Rob Warnock, 30-3-510 <····@sgi.com>
SGI Network Engineering <http://www.rpw3.org/>
1600 Amphitheatre Pkwy. Phone: 650-933-1673
Mountain View, CA 94043 PP-ASEL-IA
[Note: ·········@sgi.com and ········@sgi.com aren't for humans ]
* ·····@unlambda.com (James A. Crippen)
| Really? 7 bit? That doesn't fit very well into a 36 bit word... I
| know it was supported in most systems for ASCII obviously, but didn't
| think that it would be used internally in whatever OS was running...
Yes, 7-bit files were the norm on TOPS-10 and -20. That wastes one bit for
every 5 characters. A byte would never cross a word boundary. When writing
binary files for 8-bit computers, two models were used: one that used normal
8-bit bytes and wasted a nybble at the far end of each word, and one that
used 9-bit "quarter-words" where the extra bit was used for parity. I used
one of these tools to build binaries for various 8-bit controllers and even
compiled Kermit for a CP/M-based system.
| What do you put in the other 0.142857142857...th of the word once you've
| stuffed in the five 7-bit characters? Maybe a parity bit?
Zero. The editor SOS could actually store a five-digit line number with this
spare bit set to one, and several text processing tools, such as compilers,
would know to ignore this word. It is still quite amazing that people worry
about what a spare bit could be used for, while their gigabyte machines spend
99.8% of their CPU power pondering how to idle more efficiently.
--
Guide to non-spammers: If you want to send me a business proposal, please be
specific and do not put "business proposal" in the Subject header. If it is
urgent, do not use the word "urgent". If you need an immediate answer, give
me a reason, do not shout "for your immediate attention". Thank you.
Erik Naggum <····@naggum.net> writes:
> Zero. The editor SOS could actually store a five-digit line number with this
> spare bit set to one, and several text processing tools, such as compilers,
> would know to ignore this word. It is still quite amazing that people worry
> about what a spare bit could be used for, while their gigabyte machines spend
> 99.8% of their CPU power pondering how to idle more efficiently.
Indeed. It makes me feel good to see the load on one of my boxen rise
above 1. Sad, really. Almost makes me want to go back to hardware
where that sort of thing mattered. But not quite. ^_^
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
In article <················@naggum.net>, Erik Naggum <····@naggum.net> wrote:
> Zero. The editor SOS could actually store a five-digit line number with this
> spare bit set to one, and several text processing tools, such as compilers,
> would know to ignore this word. It is still quite amazing that people worry
> about what a spare bit could be used for, while their gigabyte machines spend
> 99.8% of their CPU power pondering how to idle more efficiently.
Back when memory was priced in kilobytes instead of megabytes, and process
address spaces on mainframes were limited to a small number of megabytes
rather than at least a gigabyte, every bit counted. There's a reason why
"bit-twiddling" was a revered art in those days. If someone could find a
way to use that extra bit, it could occasionally make a big difference in
the capabilities of the application.
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
On 20 Jun 2002 09:00:29 -0800, ·····@unlambda.com (James A. Crippen) wrote:
> The reason that 8 bits per byte caught on was because of the influence
> of 8-bit microprocessors like the Intel 4004 series. Those were in
Wasn't the 4004 a 4-bit microprocessor?
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
Paolo Amoroso <·······@mclink.it> writes:
> On 20 Jun 2002 09:00:29 -0800, ·····@unlambda.com (James A. Crippen) wrote:
>
> > The reason that 8 bits per byte caught on was because of the influence
> > of 8-bit microprocessors like the Intel 4004 series. Those were in
>
> Wasn't the 4004 a 4-bit microprocessor?
Right. And the 8008, its successor was 8 bit.
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
> 36-bit systems typically used 6-bit bytes for simple printable
> characters, called SIXBIT ASCII or simply SIXBIT. Or ASCIZ??
ASCIZ simply means a 0-terminated ASCII(oid) string, like C uses. In
some assemblers, it was a pseudo-op, a la:
.ASCIZ "hello"
would emit (to borrow C syntax, sorry) the sequence "hello\0". I'm
ignoring byte sizes here, since they're orthogonal to this concept.
Related: Does anybody have a SIXBIT conversion map readily available?
Cheers,
joelh
Joel Ray Holveck <·····@juniper.net> wrote:
+---------------
| Related: Does anybody have a SIXBIT conversion map readily available?
+---------------
See my other response, but briefly: ASCII 040-137 (octal) maps to
SIXBIT 0-77, and alphabetics in ASCII 140-177 also map to SIXBIT 40-77.
-Rob
-----
Rob Warnock, 30-3-510 <····@sgi.com>
SGI Network Engineering <http://www.rpw3.org/>
1600 Amphitheatre Pkwy. Phone: 650-933-1673
Mountain View, CA 94043 PP-ASEL-IA
[Note: ·········@sgi.com and ········@sgi.com aren't for humans ]
Oleg <············@myrealbox.com> wrote:
+---------------
| Andreas Holz wrote:
| > I found a reference to a port of the MIT ChaosNet code to Linux on:
| > http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
| > latter is defunct. Does someone know how to get this code?
|
| Does anyone know _why_ they used 36-bit words??? Why not 2^n?
+---------------
Uh... Maybe because of <URL:http://www.36bit.org/dec/>?!? ;-} ;-}
Don't forget what MacLisp originally ran on...
-Rob
-----
Rob Warnock, 30-3-510 <····@sgi.com>
SGI Network Engineering <http://www.rpw3.org/>
1600 Amphitheatre Pkwy. Phone: 650-933-1673
Mountain View, CA 94043 PP-ASEL-IA
[Note: ·········@sgi.com and ········@sgi.com aren't for humans ]
Oleg <············@myrealbox.com> writes:
>
> Does anyone know _why_ they used 36-bit words??? Why not 2^n? (Or say 2^5 -
> 1, like O'Caml's integer?)
Probably a legacy from the PDP-10s, which had 36 bit words. I think the
original architectural source of this was based on having 6 six-bit
bytes in a word. A number of early machines had a more compact
character set that encoded in 6 bits. It didn't use lower-case letters,
so you still had 64 - 26 - 10 = 28 characters left over for punctuation
and other symbols.
--
Thomas A. Russ, USC/Information Sciences Institute ···@isi.edu
······@topinform.com (Andreas Holz) writes:
> I found a reference to a port of the MIT ChaosNet code to Linux on:
> http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
> latter is defunct. Does someone know how to get this code?
It seems I have downloaded it back when it was available at that
location. I have put it temporarily to
http://www.iki.fi/azure/tmp/chaos-112499.tar.gz
--
Hannu
Hannu Koivisto <·····@iki.fi> wrote in message news:<··············@lynx.ionific.com>...
> ······@topinform.com (Andreas Holz) writes:
>
> > I found a reference to a port of the MIT ChaosNet code to Linux on:
> > http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
> > latter is defunct. Does someone know how to get this code?
>
> It seems I have downloaded it back when it was available at that
> location. I have put it temporarily to
> http://www.iki.fi/azure/tmp/chaos-112499.tar.gz
Hannu,
thank you very much!!!
Andreas
Hi Hannu,
I found a backup of Brad Parkers site on http://info.alexa.com and
contacted him last week. His new site is http://www.heeltoe.com and on
his ftp server (ftp://ftp.heeltoe.com/pub/chaos) there are some more
versions.
He has as well a much newer version ready which was never published
and is planning to put it on his ftp server next week.
Cheers,
Marc
······@topinform.com (Andreas Holz) wrote in message news:<···························@posting.google.com>...
> Hannu Koivisto <·····@iki.fi> wrote in message news:<··············@lynx.ionific.com>...
> > ······@topinform.com (Andreas Holz) writes:
> >
> > > I found a reference to a port of the MIT ChaosNet code to Linux on:
> > > http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
> > > latter is defunct. Does someone know how to get this code?
> >
> > It seems I have downloaded it back when it was available at that
> > location. I have put it temporarily to
> > http://www.iki.fi/azure/tmp/chaos-112499.tar.gz
>
> Hannu,
>
> thank you very much!!!
>
> Andreas
From: Christopher C. Stacy
Subject: Re: MIT ChaosNet code port to Linux
Date:
Message-ID: <uznxpu9pp.fsf@grant.org>
>>>>> On 19 Jun 2002 23:55:39 -0700, Andreas Holz ("Andreas") writes:
Andreas> Hello all,
Andreas> I found a reference to a port of the MIT ChaosNet code to Linux on:
Andreas> http://www.36bit.org/symbolics/ to http://www.parker.boston.ma.us. The
Andreas> latter is defunct. Does someone know how to get this code?
CHAOSNET was a local area network protocol similar to Ethernet.
It was developed at the MIT AI Lab for the Lisp Machines,
In 1975 there were no commercially available LANs -- nor was
there anything to hook up to them -- and the hackers there
were familiar with Ethernet that was created at Xerox PARC.
But CHAOSNET doesn't really have anything to do with Lisp per se.
Above the hardware level, CHAOSNET was a connection-based
stream-oriented protocol providing both reliable and
unreliable messages in the stream. There was simple routing.
Control messages were not a seperate protocol or layer.
About the only remarkable feature I can think of was that the
service names were symbolic: instead of a "foreign port"
number like 25, you used a string like "MAIL".
The original implementations were for the Lisp Machine (in Lisp,
of course) and in-10 assembler (MIDAS) for ITS. Later on, there
were implementations for UNIX (C) and VMS (BLISS).
When TCP/IP became a stable standard, CHAOSNET was mostly
abandoned, although some of the CHAOSNET protocols continued
to be used over top of TCP.
I can't think of any reason why anybody would want to
use CHAOSNET today.
······@grant.org (Christopher C. Stacy) writes:
> When TCP/IP became a stable standard, CHAOSNET was mostly
> abandoned, although some of the CHAOSNET protocols continued
> to be used over top of TCP.
>
> I can't think of any reason why anybody would want to
> use CHAOSNET today.
Except for either historical reasons or to get a LispM working that
didn't have TCP installed. And if you have the latter you could
probably get TCP for if you asked the right people...
Although if you're out to prove to networking weenies that TCP isn't
the only answer, then it's pretty neat to have Chaosnet running on
your network. Confuses the hell out of them when they sniff packets.
It's worth it to see their expression.
Cisco routers still have Chaosnet support as an option. I've seen a
few that are willing to route it. But it's usually on by accident, or
because the network manager is a goofbrain who doesn't know what he's
doing.
But IP/TCP is arguably better than Chaosnet. And it's certainly more
widely ported.
What *I* would like to see is a modern SUPDUP implementation for Unix.
Both client and server. Over TCP.
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
In article <··············@kappa.unlambda.com>,
James A. Crippen <·····@unlambda.com> wrote:
>Although if you're out to prove to networking weenies that TCP isn't
>the only answer, then it's pretty neat to have Chaosnet running on
>your network. Confuses the hell out of them when they sniff packets.
>It's worth it to see their expression.
It's probably easier to accomplish that with a couple of Macintoshes
running Appletalk.
>Cisco routers still have Chaosnet support as an option. I've seen a
>few that are willing to route it. But it's usually on by accident, or
>because the network manager is a goofbrain who doesn't know what he's
>doing.
We used to use Cisco routers as Chaosnet routers when I was at Thinking
Machines. We had a class B network, with 8 bits of subnetting, so we
configured a direct correspondence between our IP subnet/host numbers and
the Chaosnet network/host numbers. And later on we configured the same
correspondence with Appletalk network numbers and DECnet. This made
network administration much easier, only having to know one ID for each
subnet.
>What *I* would like to see is a modern SUPDUP implementation for Unix.
>Both client and server. Over TCP.
SUPDUP was definitely cool. I think there used to be a Unix implementation
in my MIT days, but I'm not sure.
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
Barry Margolin <······@genuity.net> writes:
> SUPDUP was definitely cool. I think there used to be a Unix implementation
> in my MIT days, but I'm not sure.
If all else fails both the Symbolics and TI implementations (both
obviously of CADR vintage) would provide a reference to work against.
I just looked at the TI version, and it's not terribly hairy.
And Mark Crispin's paper on it is still available. As is the official
RFC.
I wonder what the RFC-Editors would do if someone tried to submit a
RFC for a secure SSH-like extension to SUPDUP?
One really great advantage is that SUPDUP can do basic bitmap
graphics. I don't recall whether color was supported but it'd be
addable. SUPDUP is a *lot* cheaper than X for bitmap graphics over
the wire.
12-bit ITS characters would be interesting... I wonder if they're all
in Unicode?
'james
--
James A. Crippen <·····@unlambda.com> ,-./-. Anchorage, Alaska,
Lambda Unlimited: Recursion 'R' Us | |/ | USA, 61.20939N, -149.767W
Y = \f.(\x.f(xx)) (\x.f(xx)) | |\ | Earth, Sol System,
Y(F) = F(Y(F)) \_,-_/ Milky Way.
·····@unlambda.com (James A. Crippen) writes:
> What *I* would like to see is a modern SUPDUP implementation for Unix.
> Both client and server. Over TCP.
Here's a start:
http://www.nocrew.org/software-supdup.html
It's not tested (is anyone running a SUPDUP server?), so it's
certainly buggy.
--
Lars Brinkhoff http://lars.nocrew.org/ Linux, GCC, PDP-10,
Brinkhoff Consulting http://www.brinkhoff.se/ HTTP programming
>>>>> On 21 Jun 2002 11:03:14 +0200, Lars Brinkhoff ("Lars") writes:
Lars> ·····@unlambda.com (James A. Crippen) writes:
>> What *I* would like to see is a modern SUPDUP implementation for Unix.
>> Both client and server. Over TCP.
We had that back in the mid-80s, so the trick is just finding it.
I'd look around in public FTP sites like PREP and RTFM.
·····@unlambda.com (James A. Crippen) wrote in message news:<··············@kappa.unlambda.com>...
> What *I* would like to see is a modern SUPDUP implementation for Unix.
> Both client and server. Over TCP.
I googled for it and found
http://www.nocrew.org/software-supdup.html (recent)
http://www.mit.edu/afs/net.mit.edu/tools/src/supdup/ (ancient)
Unrelated but funny: http://www.geocrawler.com/archives/3/337/1986/8/0/1873209/
In article <·············@grant.org>,
Christopher C. Stacy <······@grant.org> wrote:
>The original implementations were for the Lisp Machine (in Lisp,
>of course) and in-10 assembler (MIDAS) for ITS. Later on, there
>were implementations for UNIX (C) and VMS (BLISS).
Don't forget TOPS-20 and Multics. Pretty much any OS that was in use at
MIT in the early 80's got a Chaosnet implementation written for it, as it
was the de facto standard campus networking protocol, before TCP/IP took
over the world.
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
······@grant.org (Christopher C. Stacy) wrote in message
(snip)
> CHAOSNET was a local area network protocol similar to Ethernet.
> It was developed at the MIT AI Lab for the Lisp Machines,
> In 1975 there were no commercially available LANs -- nor was
> there anything to hook up to them -- and the hackers there
> were familiar with Ethernet that was created at Xerox PARC.
>
(snip)
> When TCP/IP became a stable standard, CHAOSNET was mostly
> abandoned, although some of the CHAOSNET protocols continued
> to be used over top of TCP.
>
> I can't think of any reason why anybody would want to
> use CHAOSNET today.
I'm not suggesting trying make the world use CHAOSNET again, but
were there any good ideas in the CHAOSNET protocols that were not
picked up on by the TCP/IP and Unix networking communities?
I did read David Moon's AI Memo #628 at
ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-628.pdf
but the scan is so faint that I probably missed something.
(By the way, I noticed that the publication looks like it was
typeset in some fashion. The fonts don't look like they were
designed by Knuth and the date is several years before Postscript.
Any idea what might of been used to generate this document?)
In article <····························@posting.google.com>,
Martin Pomije <······@MartinPomije.eiomail.com> wrote:
>I'm not suggesting trying make the world use CHAOSNET again, but
>were there any good ideas in the CHAOSNET protocols that were not
>picked up on by the TCP/IP and Unix networking communities?
The most obvious one was the use of symbolic identifiers for protocols
rather than port numbers. I think the TCPMUX protocol was inspired by
this. But it's not really that big a deal, because you still need some
system to prevent naming conflicts; you need either a worldwide registry
analogous to the IANA registry of port numbers, or a hierarchical protocol
naming system (coupling it with the DNS hierarchy might make sense,
although domain names can change as organizations evolve and merge).
Chaosnet used two different types of acknowledgements. Receipts were used
to indicate that a packet has been received, for retransmission and error
checking purposes. Acknowledgements indicated that a packet had been read
by the application process, and they were used for flow control. TCP
combines these two functions into a single acknowledgement combined with
the window. I think this turned out to be a reasonable mechanism, because
flow control also needs to deal with network congestion, not just slow
receiver processes. On the other hand, many TCP programmers seem to wish
that it provided application-level acknowledgements, rather than forcing
them to design it into the application protocols; but since Chaosnet didn't
generate acknowledgements immediately, only when at least 1/3 of the window
has been read (this is similar to TCP's Silly Window Syndrome avoidance),
it wasn't really reliable.
It had a built-in connection forwarding mechanism. A server, upon
receiving a connection request, could respond with a FWD packet containing
the address and contact name for another server. This allows for various
kinds of connection brokers and location servers.
Other than that, it was not too different from TCP/IP; it was designed
around the same time as TCP/IP was being developed to replace NCP, and they
apparently got many ideas from each other. Controlled packets are very
similar to TCP, while uncontrolled packets are like UDP. RUT packets are
similar to RIP.
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
"Martin Pomije" <······@MartinPomije.eiomail.com> wrote in message
·································@posting.google.com...
>
> I did read David Moon's AI Memo #628 at
> ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-628.pdf
> but the scan is so faint that I probably missed something.
> (By the way, I noticed that the publication looks like it was
> typeset in some fashion. The fonts don't look like they were
> designed by Knuth and the date is several years before Postscript.
> Any idea what might of been used to generate this document?)
>
Looks like `Scribe' by Brian K. Reid
It was popular at the lab around that time.
······@MartinPomije.eiomail.com (Martin Pomije) writes:
> [David Moon's AI Memo #628]
> (By the way, I noticed that the publication looks like it was
> typeset in some fashion. The fonts don't look like they were
> designed by Knuth and the date is several years before Postscript.
> Any idea what might of been used to generate this document?)
Well unless Dave Moon answers with the real dope, I can speculate a
little bit about what may have been used. IIRC popular typesetting
systems around at roughly that time were Scribe, R and possibly Bolio.
Output would have been to one of two Xerox laser printers. Either
an XGP (earlier) or a Dover (later). The XGP was rather interesting
in that it used a roll of paper rather than precut sheets. The paper
was 8.5 inches wide, but pretty much as long as you wanted...
--
Thomas A. Russ, USC/Information Sciences Institute ···@isi.edu