Hacker News new | past | comments | ask | show | jobs | submit login
Stories about the B5000 and people who were there (1979) (ed-thelen.org)
122 points by chat 29 days ago | hide | past | favorite | 38 comments

(I started writing this comment when the submitted title was “The Summer Of 1960 (Time Spent with don knuth)” and the url was specifically the section http://ed-thelen.org/comp-hist/B5000-AlgolRWaychoff.html#7 , but it still applies I guess.)

There's a PDF version at https://www.computerhistory.org/collections/catalog/10272464... which incidentally is a scan from a copy given to the Computer History Museum by Donald Knuth himself — before the title “Stories about the B5000…” he has added, in pencil, “Half-true”. :-)

Knuth tells his side of this story in video 27 (of 97) of his Web of Stories oral history: https://www.youtube.com/watch?v=QeiuVNDQg4k&list=PLVV0r6CmEs... — transcript (thanks to https://github.com/kragen/knuth-interview-2006):

> Some people from Thompson Ramo Wooldridge approached me and said, Don, we understand that you can write compilers. We’re going to put in a proposal to Burroughs to write a compiler for their machine, the Burroughs 205, for a language called ALGOL, which was just being invented at that time […] made a proposal to Burroughs for I believe it was $70,000, to create an ALGOL compiler for the Burroughs 205. The people who made this proposal really, though, were clueless about how to write compilers, so they hired me, a Case senior, to do the job, because they had heard that I knew how to do it. I had done this RUNCIBLE and a couple of versions of other software at Case, […] but Burroughs turned them down; they didn’t give them the contract.

> So after Burroughs said no, […] maybe I’ll write to Burroughs on my own, and I sent them a letter and said, I’ll, you know, for $5,000 I can write you an ALGOL compiler. Now $5,000 was a huge amount of money in 1959, 1960. I mean a college professor was making $8,000 a year or something like this. So I thought $5,000 was an incredibly rich thing, you know, to do. […]

> […] I spent the summer writing this compiler for ALGOL, for the Burroughs 205, and I wrote it, but really I had it only in pencil and paper, I didn’t have it ready to go, and then I would take it with me on, as I went out to Pasadena, and work on it there when I was at the Burroughs plant in Pasadena.

> So on my way out West; I had a little Volkswagen, that I had gotten from my parents, and I drove 100 miles a day, and got a motel, and sat down, and wrote code, wrote software, and took 30 days to drive from Milwaukee to Pasadena, every day writing a little bit of this software. Then I got to Pasadena, and had all my code, had all my notes, and started putting it on to punched cards, and you know, debugging it and by Christmas time I had their compiler for them […] I heard for the next ten years that people in Brazil were still using it a lot.

> And so it was a, it was an interesting experience for me, but the most important, from my point of view, was I had $5,500, which was enough to get married. And so in the summer of ‘61 Jill and I got married, and it paid for our honeymoon trip in Europe, which was our first time seeing the world.

The actual compiler “source code” (written in pencil, assembly language and flowcharts) seems to be this one: http://archive.computerhistory.org/resources/text/Knuth_Don_...

There's also 43-page “documentation” of the compiler http://archive.computerhistory.org/resources/text/Knuth_Don_... which starts with “How does this compiler work? Frankly, it's a miracle if it does”.

Also in the same interview, he reveals something about how he ended up getting a master's degree (as mentioned in the story here):

> […] second half of my freshman year, I started having a little problem with my grades, and so I had to give up ping-pong.

> But starting in my sophomore — junior year, I found out that you could take graduate courses at Case, and they were easier than the undergraduate courses. The reason is that Case had really strict admissions requirements for undergrads, but they were fairly loose about admitting graduate students. […]

> And as a result, I had accumulated also, by the time I was a senior, I had accumulated lots and lots of graduate credits. Now, as a result then, Case did, on Graduation Day, Case did an unprecedented thing that had never been done before, they awarded me a Master’s Degree, simultaneously with my Bachelor’s Degree. And this, the faculty had gotten together and [voted] unanimously that this should happen, and I remember, you know, that was another thing that got into the newspapers at the time […] I had taken these graduate courses because they were easier. I didn’t, I don’t know if I’ve ever told anybody else this before today, but that was one of the reasons I could do so many other things.

I feel like driving from Milwaukee to Pasadena 100 miles per day is the most Donald Knuth thing ever. IE, a huge task completed in the slowest and most deliberate way possible.

Ha! I imagine the point was to spend a month writing the program mainly, while also doing a little driving during breaks.

(BTW it appears that Milwaukee to Pasadena is about 2000 miles now, which works out to even less: ~70 miles a day. Or given that the interstate highway system was less developed in 1960, maybe it really was about 3000 miles then.)

It was a Volkswagen. In Summer. Through the desert probably. The cooler overheats constantly. You stop at every gas station, and you'd be lucky if there was one every 100 miles.

This is my favorite example of insane requirements:

He devoted an entire session to the French Railroad payroll program. The French Railroad had gone on an economy program and reduced their number of employees from 540000 to 360000. So that was the size of the payroll that was run on the computer in Paris. That payroll must be the most difficult payroll in the world to run. The size of the payroll is only the tip of the iceberg. An Engineers' (i. e. A train driver) salary is a function of the amount of power that he uses. So if he is on an uphill run, he makes more money than on a downhill run.

The employees live in government housing and their rent is deducted from their pay. People with a lot of dependents get more money than people with a few dependents. A veteran gets more money for each medal that he won in the war. The amount of money depends on the medal. A Purple Heart is worth more than a Sharpshooters medal.

Makes me smile - a few years ago I was working for British Telecom and had to look something up on the internal system that had all the procedures and standards.

I miskeyed the search and ended up on a TI (technical Instruction) from I think the 1940's which describe how to calculate pension entitlements taking account for war service - that was based in part on which medals you had.

> An Engineers' (i. e. A train driver) salary is a function of the amount of power that he uses. So if he is on an uphill run, he makes more money than on a downhill run.

...what? Why? I get the rest of the quirks listed (rewarding service, supporting families, fine), but what possible reason would they have for rewarding energy used? Is it just a bad proxy for distance?

Perhaps it's something that comes of the times of steam machines? Think that on steam machines, the engineering need to put carbon more frequently if you need more energy.

I'm guessing that having to use more power is a bad proxy for perceived difficulty of engineer work.

The submitted URL was http://ed-thelen.org/comp-hist/B5000-AlgolRWaychoff.html#7, but the best way to read this classic is to begin at the beginning, realize that virtual memory is going to get invented along the way, hit the "Bob would fly to Dallas for one day and teach them how to write a compiler" part, and then have your mind additionally blown when "don knuth" shows up.

My “first” computer at home was a Burroughs B80. My Dad bought it for his accounting business in the late 70s. It was about the size of two dishwashers, had an 8in floppy, a built in printer and a small flatscreen display (orange on black characters) on a swing arm above the keyboard.

I remember flipping through the B80’s manuals and finding a software section. We could get games for it! I asked dad if we could order some, but unfortunately, he said, the accounting software supplier would void their warrantee if we were to install any other software on the machine.

All of my computer time before buying our Apple ][+ a few years later was spent “playing” data entry on the B80 for Dad’s business.

Hey, I used one of those in an accountants in the early 80's, with the same weird orange and black screen. I recall there being no "enter" key, but several keys marked OCK1, OCK2.. etc (Operators Control Key). That was a good piece of design rather than a single "Ctrl" key on other machines.

I swear that printer could be heard several streets away!

We had a hard disk cabinet that took "cassette packs" with disk platters in them (maybe 15 inches in diameter). The engineer used to have to come out to it and re-align the heads every couple of weeks as they were not very stable.

I didn't realise there were games for it, dammit. I managed to get hold of a Cobol compiler for it, but with no other technical information about the B80, didn't get very far. No internet in those days kids.

I can't recall if the B80 had it, but there were small satellite workstations that looked similar and had a small silver button under the desk at exactly knee height. On my first day I was introduced to the "shit button". So named because if you accidentally knocked it, it reset the machine and lost all your work. Most people taped a small cover over it.

Fond memories of the B80, and it's big brother the B800 which I used at a different job. Boy was that sophisticated... it needed a paper tape through a "rat trap" to boot it.

> I recall there being no "enter" key, but several keys marked OCK1, OCK2.. etc (Operators Control Key). That was a good piece of design rather than a single "Ctrl" key on other machines.

I was even more impressed with the existence of "Go" key (allowing to signal the successful end of the form entry and to start the action, which was different than just using "enter" to end the entering of one field) on the Burroughs 20 line (with the https://en.wikipedia.org/wiki/Convergent_Technologies_Operat... ). It's making a lot of endings of "dialogs" much more logical, as well as the movement through the fields -- enter is just moving to the next field, not ending the dialog or doing whatever is selected, like in Windows.





Immediately loved this bit: “We spent the first two months designing the compiler. Then we coded for a month.“

Discussed a bit in 2011: https://news.ycombinator.com/item?id=2856567. See also:

2011 https://news.ycombinator.com/item?id=2855508 - Oral History of Bob Barton and the Burroughs B5000 team (1985)

2012 https://news.ycombinator.com/item?id=4009999 - The Burroughs B5000 - 20 Years Later and Still Ahead of the Times?

2013 https://news.ycombinator.com/item?id=6988535 - The Architecture of the Burroughs B5000 - again in 2016: https://news.ycombinator.com/item?id=10822777

https://news.ycombinator.com/item?id=2855500 is a 2011 comment on an Alan Kay talk which gives some background

2011 https://news.ycombinator.com/item?id=2893454 - The Descriptor: a definition of the B5000 information processing system (1961)


This is the fantastic web-based B5000 emulator.

This page is so old school that I looked at the source HTML and learned something.

U tag: What is that? According to w3schools, it "represents some text that is unarticulated and styled differently from normal text."

B tag: What is it? Bring attention to elelemnt - or, in most browsers, boldface (huh).

So, put them together and you get those underlined section headings.

New to me!

Not to veer too far into Reddit territory, but wow that makes me feel old.

<a> <b> <i> <p> and <u> were just about all the tags we had in 1994!

The heading tags (<H1> to <H6>) were there (and implemented, unlike the <HPX> "highlighted phrase" tags from tbl's list) from the beginning as well. So were <DL>, <DT> and <DD>, along with <UL> and <LI> for lists that weren't glossary terms. We also had <PLAINTEXT> and <LISTING> precursors to <pre>, <tt> (may it rest in peace) and <code>. (I couldn't tell you what they looked like in a graphical browser as I was using Lynx on DOS boxes as the time - HTML was handy even without HTTP on our parallel-port-and-telephone-wire network.) There were other tags that didn't last very long, too, like the <ADDRESS> tag for the author's meatspace address (makes sense for scientific collaboration, not so much for, say, political discussion boards).

developer.mozilla.org sheds some (slightly confusing) light on that: It used to mean underline..uh rather, <u> still makes an underline but should instead be used for such things as squiggly lines under misspelt words –

"The HTML Unarticulated Annotation Element (<u>) represents a span of inline text which should be rendered in a way that indicates that it has a non-textual annotation. This is rendered by default as a simple solid underline, but may be altered using CSS.

This element used to be called the "Underline" element in older versions of HTML, and is still sometimes misused in this way. To underline text, you should instead apply a style that includes the CSS text-decoration property set to underline. ...

Along with other pure styling elements, the original HTML Underline (<u>) element was deprecated in HTML 4; however, <u> was restored in HTML 5 with a new, semantic, meaning: to mark text as having some form of non-textual annotation applied.

Valid use cases for the <u> element include annotating spelling errors, applying a proper name mark to denote proper names in Chinese text, and other forms of annotation.

You should not use <u> to simply underline text for presentation purposes, or to denote titles of books.

To underline text without implying any semantic meaning, use a <span> element with the text-decoration property set to "underline"..."


I use them constantly. mainly for shortness <u> is 80% less than <span class"whatever">

U is underline AFAIK; what would "unarticulated" even mean?

I think it used to mean 'underline', then got changed because that was considered undesirable.

From the link above:


> You should not use <u> to simply underline text for presentation purposes, or to denote titles of books.

> To underline text without implying any semantic meaning, use a <span> element with the text-decoration property set to "underline"..."

Way to go make a guy under 35 feel old!

Can anyone ELI5 this passage:

However, the 205 drum was more sophisticated. It was divided into two areas. The primary storage was 80 words of 0.85 millisecond average access memory. The secondary storage was 4000 words of 8.5 millisecond average access memory. The fast memory was accomplished by placing the read-head one tenth of the way around the drum from the write head. Thus anything that was written was available one tenth of a rotation later.

I’m confused how the mechanism as described could be considered “fast storage”. What if the word I want to read isn’t the one I wrote a tenth of a rotation ago? Was there some kind of refresh scheme involved so the same 80 words were rewritten ten times along each rotation? But if you could keep track of 80 words you wanted to write periodically, you wouldn’t need to...

I'm guessing the write head copied the read head unless instructed to write a new thing at that address, so you didn't need to keep track separately.

Algorithms (implemented in parallel with electronics):

Secondary storage algorithms:

Read(addr): While address != addr: nop Return read_head_value

Write(addr, data): While address != addr: nop Write data

Fast storage:

Read(addr): While address % 10 != addr: nop Return read_head_data

Write(addr, data): While address % 10 != addr: Write read_head_data Write data

That's it. See description on page 3 of the manual: http://bitsavers.org/pdf/burroughs/electrodata/205/3021_B205...

That manual is great! I highly recommend reading through it for anyone interested in computing history - and anyone interested in how to communicate clearly in technical writing.

Here's a fun report from someone who had the 205 as their first personal computer:


I loved this story at the end:

> Skip on Minus

> One of the programs that I wrote during the summer at the University of Utah involved a loop that was exactly 20 instructions long. That meant the entire loop could be loaded into the high speed memory. It didn't even need the jump instruction from the end of the loop back to the beginning. It would just continue execution from the duplicate of the code in the next block on the drum. The trouble was there was no way to exit the loop.

> I needed a "Skip on Minus" instruction. There was a "Skip on Plus", but no "Skip on Minus". The EE grad student who maintained the machine was a guy named Joe. I wish I could remember his last name. Anyway, I told him I needed a "Skip on Minus" instruction. He said, "I'll put one in". He disappeared behind the cabinets with circuit diagrams and a soldering iron. He called out, "the op code will be 51".

> I wrote my program with a "51" instruction. It worked perfectly. And so the University of Utah had the only Burroughs 205 Datatron in the world with a "Skip on Minus" instruction.

This is head-per-track drum/disk (none of this new fangled seeking stuff) - probably the slow tracks has a single set of R/W heads per track while the fast tracks had multiple heads spaced around the drum.

When I was a B6700 systems hack, mid 70s, we still had head-per-track disks for system files (and paging/swapping) and slower seeking (removeable) disk packs for system files

> It also occurred to me that if the language could describe itself (i.e. if the language and metalanguage were one in the same), and if the compiler were written in its own language, then all I would have to do to change the language would be to change, the metalinguistic description and recompile the compiler three times and I would have a new compiler for the new language.

An epiphany for the author: can a compiler be self-compiled? Bootstrapping would later be implemented in the B5000 but it had actually been accomplished 3 years earlier by the Naval Electronics Laboratory in 1958 https://en.wikipedia.org/wiki/Bootstrapping_(compilers)#Hist...

This seems to be claiming that virtual memory wasn't invented -- or at least first implemented -- at Manchester for ATLAS. Is there justification for that, as opposed to when it was first commercially available or in service?

I think that this was a time when lots of stuff was being invented, (and implemented for the first time) often by different people in different places at the same time.

Certainly Burroughs' implementation of VM is VERY different from what we normally think of as VM - but then their architecture (a stack machine with tagged memory) is also very different

What is the story behind only using lowercase in "don knuth?"

> In June we were introduced to this tall college kid that always signed his name with lowercase letters. He was don knuth.

Now what is the story behind that?

was he bootstraping a preliminary version of Erik Naggum?


(just joking)

> Don said that he would not need the card reader or

looks like they slipped up

“We spent two months designing the compiler”

“Then we coded for a month”

Can you imagine doing this today at your job?

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact