Post by Louis KruppPost by Stephen FuldPost by Louis KruppPost by Peter FlassPost by Louis Krupphttps://dl.acm.org/doi/pdf/10.1145/365230.365233
Yes, and? B5500 ALGOL was a very good implementation of
ALGOL-58, except that stream procedures bypassed all the
hardware protection mechanisms. I think Burroughs fixed this on
later machines. ALGOL was later sunk by the development of
ALGOL-68, which (AIUI) was more different from ALGOL-60 than
C++ is from C.
No, B5000 and B5500 ALGOL were implementations of ALGOL-60, not
ALGOL-58, but the hardware and compiler were designed and implemented
before the Revised Report was published in January 1963.
Burroughs 220 BALGOL was closely based on ALGOL-58 (although it wasn't
called that originally -- it was the International Algorithmic Language,
or IAL). ALGOL-58 was never a real language design, just a progress
report on the work that eventually produced ALGOL-60.
Post by Louis KruppPost by Stephen FuldPost by Louis KruppStream procedures could manipulate words that had the flag bit
set, and to the best of my recollection, that's the only hardware
protection the B5500 had. The Large System series -- the
B6500/6700 on up -- had a more complete capability architecture
with three tag bits, and compilers that generated user programs
wouldn't emit operators that would touch words with odd tags.
As a teenage nerd, I thought stream procedures were the coolest thing ever.
Yes, Stream Procedures were very cool, and very useful, and very, very
dangerous. They were included in Burroughs Extended ALGOL to give access
to the B5000's Character Mode instructions, which had been a (somewhat
panicked) late addition to the architecture to support the large market
that Burroughs had in commercial business applications, and to support
the then very-new language COBOL. Bypassing hardware-enforced memory
protection was the price for that addition.
The B6500/6700/7700 did indeed fix the lack of memory protection with
the B5000/5500s Character Mode. It also fixed what I think was a more
serious ALGOL-related problem -- the inability of the B5000/5500 to
address intermediate nested scopes in a program. The older machine could
only address the global (outer block) variables and those in the current
local procedure. The hardware simply didn't have the ability to address
any nesting levels between those two.
Post by Louis KruppPost by Stephen FuldPost by Louis KruppIf Burroughs Large Systems -- or their Unisys successors -- had
attracted more users, especially at universities, there might
have been a reason to design a practical and portable version of
ALGOL.
Given that the original Algol didn't specify any I/O, so each
implementation did their own, it was hard to be portable. In fact
one "definition" of Pascal, was Algol plus I/O.
Burroughs Extended ALGOL borrowed formatting from FORTRAN, changing
FORMAT statements to FORMAT declarations. It seemed natural and
obvious at the time; it would be surprising -- and unfortunate -- if
no other ALGOL implementations did something similar.
Actually, the B5000/5500's formatting came from 220 BALGOL and was no
doubt heavily influenced by FORTRAN, although FORMAT declarations in
B5000 Extended ALGOL were certainly made more FORTRAN-like than they
were in BALGOL.
In the original B5000 ALGOL implementation, formatted I/O was the only
kind available. There was an ability to do unformatted reads and writes
via the RELEASE statement, but that manipulated physical buffers, much
like Direct I/O does on the later systems, and required the use of
Stream Procedures to access the data. The "array-row I/O" we all know
didn't arrive until the MCP was rewritten (in a higher-level language,
ESPOL) for the B5500.
Post by Louis KruppPost by Stephen FuldPost by Louis KruppBurroughs Extended ALGOL and Large Systems' architecture were
said to have been designed together; I attended a few Burroughs
users' conferences until about 1982, and portability of source
programs to other systems was a concept I never heard discussed.
I would guess that most users of Burroughs Extended ALGOL had no
idea that the language had a history outside Burroughs and that
things called ALGOL-58 and ALGOL-60 existed. I certainly didn't
have a clue.
There were Algol compilers for many different architectures. For
example, the Univac 1100 series actually had two different ones.
Lack of compilers wasn't a major factor in Algol's lack of
popularity.
Let's not forget that there were two ALGOL compilers for the B5500 as
well, the original Extended ALGOL with Stream Procedures (plus several
other extensions with which you could undo both yourself and the system
if used improperly), and Compatible ALGOL (or XALGOL), which was
designed to be much safer to use, especially with timesharing systems,
and which would be much easier to port to the upcoming B6500. It used
the syntax that had been developed to support the B6500's string
operators, but was implemented for the B5500 by means of intrinsic
functions.
Let's also remember that the B5500 had two COBOL compilers -- the
original COBOL-61 and the later ANSI COBOL-68 compiler. So Univac's sins
in that regard, as mentioned in a later post to this thread, were hardly
unique.
Post by Louis KruppBurroughs users tended to be an insular bunch, and I was no
exception. I recall one users conference attendee saying "If my firm
changes systems, I'll change firms." I never imagined that I'd ever
be working on anything else.
<snip>
Louis
Paul