Anecdote prompted by the advent of Burroughs in this thread:
At the 1968 NATO conference on Software Engineering, the discussion
turned to language design strategies. I noted that the design of Algol
68, for example, presupposed a word-based machine, whereupon Burroughs
architect Bob Barton brought the house down with the remark, "In the
beginning was the Word, all right--but it was not a fixed number of
bits!"
[Algol 68's presupposition is visible in declarations like "long long
long ... int". An implementation need support only a limited number of
"longs", but each supported variety must have a definite maximum
value, which is returned by an "environment enquiry" function. For
amusement, consider the natural idea of implementing the longest
variety with bignums.]
Doug
The error was introduced on 13 September 2005, by an anonymous user from an IP address allocated to Web Perception, a Californian ISP, and (currently) geolocated to Sonoma. The change comment was:
Changes - 386BSD factual errors corrected, potentially libelous statements removed, links updated, refocus on 386BSD history, authority-386BSD authors, published works, DMR refs
The same IP address was used for a series of edits over 2005-2006, to topics including 386BSD, Lynne Jolitz, William Jolitz, and Radiocarbon Dating.
I imagine it was simply a mistake.
d
> On 10 Sep 2022, at 12:26, Grant Taylor via COFF <coff(a)tuhs.org> wrote:
>
> On 9/9/22 8:05 PM, Greg 'groggy' Lehey wrote:
>> Done.
>
> Thank you!
>
>> Do you have an idea about how this error crept in?
>
> No, I do not.
>
> I came to this article after reading about the DDJ DVD archive on the geeks mailing list. I was sensitive to the emails about DDJ because I've been looking to acquire the issues (or at least articles) with the Porting Unix to the 386 articles in them.
>
> Now I have them! :-D
>
>
>
> --
> Grant. . . .
> unix || die
>
https://www.timeanddate.com/on-this-day/september/9
``Unix time or Unix epoch, POSIX time or Unix timestamp, is a time system
that measures the number of seconds since midnight UTC of January 1, 1970,
not counting leap seconds. At 01:46:40 UTC on September 9, 2001, Unix time
reached the billionth second timestamp.''
Hard to believe that it was that long ago...
-- Dave
Paul Winalski and Bakul Shah commented on bit addressable machines
on the TUHS list recently. From Blaauw and Brooks' excellent
Computer Architecture book
http://www.math.utah.edu/pub/tex/bib/master.html#Blaauw:1997:CAC
on page 98, I find
>> ...
>> The earliest computer with bit resolution is the [IBM 7030] Stretch.
>> The Burroughs B1700 (1972) and CDC STAR100 (1973) are later examples.
>>
>> Bit resolution is costly in format space, since it uses a maximum
>> number of bits for address and length specification. Sharpening
>> resolution from the byte to the bit costs the same as increasing
>> address-space size eight-fold.
>>
>> Since almost all storage realizations are organized as matrices,
>> bit resolution is also expensive in time or equipment.
>> ...
-------------------------------------------------------------------------------
- Nelson H. F. Beebe Tel: +1 801 581 5254 -
- University of Utah -
- Department of Mathematics, 110 LCB Internet e-mail: beebe(a)math.utah.edu -
- 155 S 1400 E RM 233 beebe(a)acm.org beebe(a)computer.org -
- Salt Lake City, UT 84112-0090, USA URL: http://www.math.utah.edu/~beebe/ -
-------------------------------------------------------------------------------
Doug McIlroy:
Bit-addressing is very helpful for manipulating characters
in a word-organized memory. The central idea of my ancient
(patented!) string macros that underlay SNOBOL was that it's
more efficient to refer to 6-bit characters as living at
bits 0,6,12,... of a 36-bit word than as being characters
0,1,2,... of the word. I've heard that this convention was
supported in hardware on the PDP-10.
====
Indeed it was. The DEC-10 had `byte pointers' as well as
(36-bit) word addresses. A byte pointer comprised an address,
a starting bit within the addressed word, and a length.
There were instructions to load and store an addressed byte
to or from a register, and to do same while incrementing
the pointer to the next byte, wrapping the start of the next
word if the remainder of the current word was too small.
(Bytes couldn't span word boundaries.)
Byte pointers were used routinely to process text. ASCII
text was conventionally stored as five 7-bit bytes packed
into each 36-bit word. The leftover bit was used by some
programs as a flag to mean these five characters (usually
the first of a line) were special, e.g. represented a
five-decimal-digit line number.
Byte pointers were used to access Sixbit characters as
well (each character six bits, so six to the word,
character set comprising the 64-character subset of
ASCII starting with 0 == space).
Norman Wilson
Toronto ON
(spent about four years playing with TOPS-10 before
growing up to play with UNIX)
Andrew Hume:
if i recall correctly, V1 of Unix had time measured in milliseconds.
were folks that sure that this would change before wrap-around?
====
Not milliseconds (which were infinitesimally small to the
computers of 1969!) but clock ticks, 60 per second.
Initially such times were stored in a pair of 18-bit PDP-7
words, giving a lifetime of about 36 years, so not so bad.
The PDP-11's 16-bit words made that a 32-bit representation,
or about two and a quarter years before overflow. Which
explains why the time base was updated a few times in early
days, then the representation changed to whole seconds, which
in 32 bits would last about as long as 36 bits of 60 Hz ticks.
The PDP-7 convention is documented only in the source code,
so far as I know. The evolution of time on the PDP-11 can
be tracked in time(II) in old manuals; the whole-seconds
representation first appears in the Fourth Edition.
Norman Wilson
Toronto ON
Not that old a timer, but once looked into old time
> From: Jim Capp
> See "The Preparation of Programs for an Electronic Digital Computer",
> by Maurice V. Wilkes, David J. Wheeler, and Stanley Gill
Blast! I looked in the index in my copy (ex the Caltech CS Dept Library :-),
but didn't find 'word' in the index!
Looking a little further, Turing's ACE Report, from 1946, uses the term
(section 4, pg. 25; "minor cycle, or word"). My copy, the one edited by
Carpenter and Doran, has a note #1 by them, "Turing seems to be the first
user of 'word' with this meaning." I have Brian's email, I can ask him how
they came to that determination, if you'd like.
There aren't many things older than that! I looked quickly through the "First
Draft on the EDVAC", 1945 (re-printed in "From ENIAC to UNIVAC", by Stein),
but did not see word there. It does use the term "minor cycle", though.
Other places worth checking are the IBM/Harvard Mark I, the ENIAC and ...
I guess therer's not much else! Oh, there was a relay machine at Bell, too.
The Atanasoff-Berry computer?
> From: "John P. Linderman"
> He claims that if you wanted to do decimal arithmetic on a binary
> machine, you'd want to have 10 digits of accuracy to capture the 10
> digit log tables that were then popular.
The EDVAC draft talks about needing 8 decimal digits (Appendix A, pg.190);
apparently von Neumann knew that that's how many digits one needed for
reasonable accuracy in differential equations. That is 27 "binary digits"
(apparently 'bit' hadn't been coined yet).
Noel
> Doug or anyone, why do bit pointers make sense? Why?
Bit-addressing is very helpful for manipulating characters
in a word-organized memory. The central idea of my ancient
(patented!) string macros that underlay SNOBOL was that it's
more efficient to refer to 6-bit characters as living at
bits 0,6,12,... of a 36-bit word than as being characters
0,1,2,... of the word. I've heard that this convention was
supported in hardware on the PDP-10.
In the IBM 7020 floats and ints were word-addressed. But
those addresses could be extended past the "decimal point"
to refer to bits. Bits were important. The computer was designed
in parallel with the Harvest streaming "attachment" for
NSA. Harvest was basically intended to gather statistics useful
in code-breaking, such as frequency counts and autocorrelations,
for data typically encoded in packed 5- to 8-bit characters. It
was controlled by a 20-word "setup" that specified operations on
rectangular and triangular indexing patterns in multidimensional
arrays. Going beyond statistics, one of the operations was SQML
(sequential multiple lookup) where each character was looked
up in a table that specified a replacement and a next table--a
spec for an arbitrary Turing machine that moved its tape at
byte-streaming speed!
Doug
> Well, you can imagine what happened when the leading digit changed
> from an ASCII "9" to an ASCII "1". Oops.
I first saw a time-overflow bug more than 60 years ago. Accounting
went haywire in the Bell Labs' comp center on day 256 of the year,
when the encoded output of a new time clock reached the sign bit.
Doug
On Thu, Sep 8, 2022 at 12:51 PM segaloco via TUHS <tuhs(a)tuhs.org> wrote:
> Both Coherent and 4.4BSD have stuck out to me as examples of
> not-quite-so-clean-room implementations that did well enough (more than
> enough for BSD) and didn't die a fiery death in litigation (as much as USL
> tried...).
Be careful with that statement both parts of it are not wholly on target.
In the first, AT&T chose not to litigate against Coherent fully. As was
pointed out, Dennis and the team that examined the code base determined it
was 'clean enough.' If I recall, his comment was something like "It was
clear they had seen and had access to the AT&T IP at some point, most
likely at University (IIRC many of the founders were ex-University
Waterloo), but they did not find evidence of direct copying of files."
BSDi/UCB *vs. *USL was a different kettle of fish altogether. As has been
discussed here extensively (and needs not to be repeated), that suit was
about *Trade Secrets and >>ideas<< that make up what we call UNIX.* The
real interesting thing about that case is that had USL/AT&T won, the
repercussions for the industry would have been way beyond just BSDi - *but
all of the UNIX clones* and many of us on this list who had been "mentally
contaminated" with AT&T's ideas (I still have my 'mental contamination'
button somewhere in my archives).
The good news is that the US courts had the good sense to realize that the
moment the US Gov put the consent decree down in 1956 and required that
AT&T make their IP available and then enabled AT&T had its people start to
write about their work in the open literature (in UNIX's case the original
CACM paper, but continuing with all the books, follow on papers, etc), plus
being such wonderfully active participants in the research community at
large, it could not be called a secret.
> What I find interesting is that in this day and age, it seems there is
> almost a requirement for true "clean-room" implementation if something is
> going to be replicated, which I understand to mean the team developing the
> new implementation can't be the same team that performed a detailed
> analysis of the product being reimplemented, but the latter team can
> produce a white paper/writeup/memorandum describing the results of their
> analysis and the development team can then use that so long as it doesn't
> contain any implementation details.
>
It's not "day and age" it's from the original case law -- the term was
coined by the late Arthur Kahn, Esquire who was the lead attorney for
Franklin Computers, Inc in the Franklin *vs.* Apple Case - which he
originally won and ultimately lost on appeal [Good guy BTW, particularly
for a non-technically trained person - he 'got it']. The concept is that
one group is in a dirty room and the other in a clean room. Information is
unidirectional. The dirty room can read published documentation, probe,
and test the device/implementation using standard programming techniques.
And then write a new document that describes the functionality of the
device in question. Then hand it to the folks in the clean room who can
reimplement a device to that new specification.
The point of contention in the case is if *the original documentation for
the device*, in this case, the Apple Assembler listing for Wos's Apple-II
ROMs were protected by copy once they had been transformed from their
printed form in Apple;'s red books into the binary and stored in the ROMS
themselves.
Franklin's 'dirty room' ultimately wrote a series of test programs that
demonstrated each of the externally available locations and entries in the
ROMs. This they documents and their new clean-room programmers wrote a new
set of ROM that duplicated the functionality. IIRC the story is that
Franklin ROMs were a few bytes smaller in the end. Compaq would later the
same scheme for the IBM PC.
> I would assume the current definition of a clean-room implementation only
> requires that the developers/implementors don't have access to the code of
> the parent product (source or reverse engineered), but could read manuals,
> study behavior in-situ, and use that level of "reverse engineering" to
> extract the design from the implementation, so not knowing the gritty
> details, Coherent could be a true clean-room.
>
Be careful here. I used to work for a firm that did a lot of work for
different vendors that would build some of these clean-room sub-systems (in
fact for some of the folks -- at least one -- of the readers of this
list). We were always careful for the clean-room people to be ones we
were fairly sure had not seen that customers product previously. I was
almost always on the 'dirty' team in many of those projects because I was
so contaminated with the IP of so many of our customers' work. Because we
worked for IBM, Sun, DEC, HP, DG, AT&T, *etc*. all at the same time had
their IP in-house we had very strict rules about how things were handled.
Even what sites and what sub-nets data could be on -- which system admins
had the passwords. No one person had access to all of the passwords. We
had a locked safe for each customer with secure things like passwords
(really) and rooms with locks and videos, and access doors. It was really
serious stuff.
Frankly, I think part of why we got some of the "work for hires" tasks was
because those firms trusted us to handle their IP properly. No way did we
want to contaminate something accidentally. Some projects like our big TNC
[Transparent Network Computing] system we were working on for all of IBM,
DEC, HP, and Intel simultaneously -- 4 different teams. The architects
could talk to each other, and we talked about common issues, but it was a
different code. I know we implemented things a couple of times - although
we got smarter. For instance, the original RPC marshaling was done for
IBM with 'the awk script from hell' which later became an interface
generator that all four teams used.
>
> BSD is a different beast, as they were literally replacing the AT&T source
> code before their eyes, so there isn't much argument that can be made for
> 4.4BSD being a "clean-room" implementation of UNIX.
It was not a clean-room as Arthur defined it. It was rewritten over time,
which replaced AT&T's implementation. Which is all that was ever claimed.
> Given that, that's one of the more surprising things to me about 4.4BSD
> prevailing in the lawsuit, because while Berkeley could easily prove that
> they had replaced most of AT&T's code, there's still the fact that their
> team did have complete and unfettered access to Bell UNIX code at least
> circa 32V.
I expect this is because you don't quite understand what happened.
> but I remember reading somewhere that CSRG students and faculty avoided
> commercial UNIX like the plague,
Hmmm, I read it on the Internet -- it must be true ;-)
CSRG had Ultrix/VAX, SunOS/3, and I believe HP-UX/PA sources. They shipped
several DEC-developed drivers in 4.1A/4.1B/4.1C -- Sam, Bill Shanon, and I
tested a couple of them on one of my machines in Cory Hall as DEC has
donated one of the 3 CAD machines [UCBCAD - a.k.a. 'coke' ], and it was the
only 'pure' DEC machine on campus - without any 3rd party HW in it. After
I graduated, I suspect Sam continued the relationship with Tom Quarles, so
4.2BSD was likely tested on that system too. But I know the RH-based TAPES
and DISKs were all straight from Shannon's SCCS Ultrix repo as he sent them
to me to try before I gave them to Sam.
> Does anyone know if there was a "formal" PDP-11 and/or VAX disassembler
> produced by Bell?
Most of the compiler kits have disassemblers, as do many debuggers -- what
are you asking?
> saying something to the effect "Rumor has it there is a PDP-11
> disassembler" but I'm curious if such tools were ever provided in any sort
> of official capacity.
>
In the mid/late-70s (*i.e.* V6/V7 time frame) there are a couple of them --
where to start -- V7 has one inside of adb, and if I recall later versions
of PCC2 has one. But if you look in the USENIX tapes you can find a couple
of pretty well-adorned ones. There was one that IIRC was done by ??Cooper
Union?? guys that spit out DEC MACRO-11 syntax for the Harvard assembler.
That should be on the TUHS archives. Thinking about it, Phil Karn had
one too that did some interesting label patch-up IIRC - which I think he
brought with him to CMU from somewhere -- but I may be miss remembering
that.