8 May
2005
8 May
'05
9:29 p.m.
Subject: Re: Infocom on PDP-11
From: Paul Koning <pkoning at equallogic.com>
Date: Sun, 08 May 2005 19:10:08 -0400
To: cctalk at classiccmp.org
Cc:
woodelf> The lack of local variables makes C very
dificult.
Huh?
That is really just convention. I can't see why it's relevent.
You're confusing the lack of a hardware stack with
the lack of local
variables. They are not at all related.
Correct. But a stack makes some forms of programming easier.
The IBM 360/370 series doesn't have a stack, and
some of its
restrictions are vaguely PDP-8 like. Nevertheless, GCC supports C
(and C++) quite nicely on those machines.
IBM360 like a PDP-8???? Explain please.
For that matter, Algol had local variables long before
C was invented,
and as you pointed out, there's an Algol for the PDP-8. (Then again,
that's not a true compiler -- it compiles to an intermediate form that
looks very much like a subset of the Burroughs 5500 instruction set.)
Using an IL was a way of making the complier easier I'd guess.
Compiler deign has become more sophisticated since.
And Unix originally appeared on the PDP-7, which you
can describe
quite reasonably as an 18-bit superset of the PDP-8. (That's
historically nonsense, but as a description it fits.)
In many ways it's pretty close. PDP-8 and PDP-7 had more
similar than different. Same for The PDP-1 and 5 that preceded both.
The PDP6 and 11 were departures as was VAX. The departures were
PDP-6,11 and VAX are very CISC in the vax case, to the extreme.
Did C exist
back then, or did that wait until Unix was ported to the PDP-11? I
don't know.
NO, PDP-11 was the first occurance for C. After that it was
ported to Honeywell6000 and the Interdata 8/32 and even the
IBM System/370. The native language for unix on PDP-7 was
B and it's influence was from BCPL. The introduction of PDP-11
was early in the life of the machine to Bell Labs and K&R were
quick to take the bare iron and endevor to put all their previous
work on the -11 to make it useful.
A lot of the register,
local variable and addressing conventions directly reflect the
PDP-11 hardware, instruction set and native addressing modes
under C.
Finally, CDC 6000s don't have a stack either, but
the first Pascal
compiler ran on that machine. Implementing a stack on a non-stack
machine (or non-stack language like Fortran-II) is a nice elementary
Exercise for the Student.
Be very careful what you call a stack or not. The PDP-8 (Straight 8)
has no hardware stack but, it has autoindex registers that are very handy
for stack implmentation. It's also not hard to store a return address
elsewhere to implement subroutine recursion. Later PDP-8a and the 6120
chip versions had a real hardware stack added. The stacks were
implemented using IOTs so it was possible to add them to any -8. The
lack of a return stack doesn't mean there isn't a set of addressing
modes to implement a software stack from all the minis and micros
I've seen.
Allison
9 May
9 May
9:58 a.m.
>>>> "Allison" == Allison
<ajp166 at bellatlantic.net> writes:
Allison> Correct. But a stack makes some forms of programming
Allison> easier.
Sure, just like CISC instructions make some things seem easier. (They
actually shift the burden to a different spot.)
> The IBM 360/370 series doesn't have a stack,
and some of its
> restrictions are vaguely PDP-8 like. Nevertheless, GCC supports C
> (and C++) quite nicely on those machines.
Allison> IBM360 like a PDP-8???? Explain please.
Small directly addressable range (128 words for the 8, 4k for the
360) is what I was thinking about.
> For that matter, Algol had local variables long
before C was
> invented, and as you pointed out, there's an Algol for the PDP-8.
> (Then again, that's not a true compiler -- it compiles to an
> intermediate form that looks very much like a subset of the
> Burroughs 5500 instruction set.)
Allison> Using an IL was a way of making the complier easier I'd
Allison> guess. Compiler deign has become more sophisticated since.
I believe the main reason is to make the code smaller. P-code
compilers have been used on the PDP-11 (the Algol compiler was ported
there, and Fortran-4 was P-code). Basic-Plus is P-code of course, and
so is Forth. Then there is UCSD Pascal.
> Finally, CDC 6000s don't have a stack either,
but the first Pascal
> compiler ran on that machine. Implementing a stack on a non-stack
> machine (or non-stack language like Fortran-II) is a nice
> elementary Exercise for the Student.
Allison> Be very careful what you call a stack or not. The PDP-8
Allison> (Straight 8) has no hardware stack but, it has autoindex
Allison> registers that are very handy for stack implmentation. It's
Allison> also not hard to store a return address elsewhere to
Allison> implement subroutine recursion. Later PDP-8a and the 6120
Allison> chip versions had a real hardware stack added. The stacks
Allison> were implemented using IOTs so it was possible to add them
Allison> to any -8. The lack of a return stack doesn't mean there
Allison> isn't a set of addressing modes to implement a software
Allison> stack from all the minis and micros I've seen.
Sure. But my point is that, even when you have NO help from the
processor instruction set, you can do a block oriented language. The
Cyber is about the most unhelpful architecture you can find: no stack,
no autoincrement registers, function call works by writing the return
address into the first word of the function, etc. And sure enough,
Wirth bitched a lot about that, but the compiler works, anyway. In
fact, it worked well enough that the first VMS Pascal compiler was a
quick hackjob on the Cyber compiler -- you can still see the Cyber
code patterns when you look at the VAX machine code that VAX Pascal
V1.0 generates -- which is quite hilarious.
paul
11:13 a.m.
At 08:58 AM 5/9/2005, Paul Koning wrote:
I believe the main reason is to make the code smaller.
P-code
compilers have been used on the PDP-11 (the Algol compiler was ported
there, and Fortran-4 was P-code). Basic-Plus is P-code of course, and
so is Forth. Then there is UCSD Pascal.
I remember the Basic+ "decompiler"... but it was simply detokenizing
and not turning a p-code back into BASIC, was it?
- John
12:34 p.m.
>>>> "John" == John Foust
<jfoust at threedee.com> writes:
John> At 08:58 AM 5/9/2005, Paul Koning wrote:
> I believe the main reason is to make the code
smaller. P-code
> compilers have been used on the PDP-11 (the Algol compiler was
> ported there, and Fortran-4 was P-code). Basic-Plus is P-code of
> course, and so is Forth. Then there is UCSD Pascal.
John> I remember the Basic+ "decompiler"... but it was simply
John> detokenizing and not turning a p-code back into BASIC, was it?
I would assume so; going all the way back to BASIC would be rather
hard.
On the other hand, there was RT11 BASIC, which also used a compact
internal format, but that one was sufficiently close to the source
that a LIST command would reconstruct the source code from the
compacted internal form.
paul
12:49 p.m.
Paul Koning wrote:
detokenizing and not turning a p-code back into BASIC,
was it?
I would assume so; going all the way back to BASIC would be rather
hard.
On the other hand, there was RT11 BASIC, which also used a compact
internal format, but that one was sufficiently close to the source
that a LIST command would reconstruct the source code from the
compacted internal form.
Basic 09 ( 6809 OS9 Basic ) Also would do the same thing. This was too
nice a
programing language to be called Basic. It also compiled into a Internal
Code or Machine
code depending how fast you wanted to run.
paul
.
12:56 p.m.
John Foust wrote:
I remember the Basic+ "decompiler"... but it
was simply detokenizing
and not turning a p-code back into BASIC, was it?
- John
There were Basic+ decompilers that would produce normal basic+
programs as output. All your comments and formatting would be
lost. They usually had problems with strange items like implied
'until's, but usually did a good job.
I actually used a couple of versions. Very useful for those programs
where the source code was lost.
One version I used would notice if you tried to decompile itself,
and would output
PRINT ''Type "?" for Help'
PRINT "[]"; \ GET \ FIELD RECOUNT AS A$
DECOMPILE A$
END
11 May
11 May
1:10 a.m.
On Sun, 8 May 2005, Allison wrote:
Eh. What's easy got to do with it? :-)
I dunno about that. I just read (and worked out on paper)
Randell's 1964 ALGOL IMPLEMENTATION book. Algol had(has) stuff no
(or few) language has today, like runtime evaluation of stacked
dynamic arguments.
As far as sophistication goes -- a better measure than simply how
clever or nifty a thing is -- how far did it advance the state of
the art? Good Algol's in the early 1960's look like stuff robbed
You're
confusing the lack of a hardware stack with the lack of local
variables. They are not at all related.
Correct. But a stack makes some forms of programming easier. For that
matter, Algol had local variables long before C was invented,
and as you pointed out, there's an Algol for the PDP-8. (Then again,
that's not a true compiler -- it compiles to an intermediate form that
looks very much like a subset of the Burroughs 5500 instruction set.)
Using an IL was a way of making the complier easier I'd guess.
Compiler deign has become more sophisticated since. from the far-flung future. A lot of the
"compilers" from that era
we'd today call p-code interpreters
(terminology changes) but man,
Algol60 is neat stuff. (Not the bloated monster Algol68 (I think
it was) became.
The Whetsone Algol compiler ran, in one pass, as fast as the
source-input reader hardware, in 7000 words of memory! Though
slow, it's a full-featured language, unlike C which is basically a
portable assembler (I loved writing in C).
Algol had it's share of horrors, but man it is the basis for
nearly all modern languages. C's block and scope structure came
directly from Algol. Python's objects (the best done of any
language I've used, I hate to admit, since I find the python
culture utterly hideous) are directly analogous to the Whetstone's
scoping -- hell you could put OO structure into the Whetstone
compiler without ruining it!
8:49 a.m.
At 12:10 AM 5/11/2005, Tom Jennings wrote:
As far as sophistication goes -- a better measure than
simply how
clever or nifty a thing is -- how far did it advance the state of
the art? Good Algol's in the early 1960's look like stuff robbed
from the far-flung future. [...]
Algol had it's share of horrors, but man it is the basis for
nearly all modern languages.
Links for the intrigued... the report:
http://www.masswerk.at/algol60/report.htm
and an implementation for MS-DOS and CP/M, with source examples:
http://www.angelfire.com/biz/rhaminisys/algol60.html
Speaking as that voice from the future, reading ALGOL makes
me say "You don't want to do it that way." GOTO had not yet
been exorcised. Did I see a computed goto, where the expression
calculates the label? Eeek. Certainly it was a step forward,
but we've also learned a lot since then. When people complain
that computer languages haven't changed much, remind them
of the stuff that's fallen out of recommended practice.
- John
11:12 a.m.
On Wed, 11 May 2005, John Foust wrote:
Speaking as that voice from the future, reading ALGOL
makes
me say "You don't want to do it that way." GOTO had not yet
been exorcised. Did I see a computed goto, where the expression
calculates the label? Eeek. Certainly it was a step forward,
but we've also learned a lot since then. When people complain
that computer languages haven't changed much, remind them
of the stuff that's fallen out of recommended practice.
I miss GOTO. It was unnecessarily expunged from the programmmer's toolbox
by elitist academics.
--
Sellam Ismail Vintage Computer Festival
------------------------------------------------------------------------------
International Man of Intrigue and Danger http://www.vintage.org
[ Old computing resources for business || Buy/Sell/Trade Vintage Computers ]
[ and academia at www.VintageTech.com || at http://marketplace.vintage.org ]
11:31 a.m.
>>>> "Vintage" == Vintage
Computer Festival <vcf at siconic.com> writes:
Vintage> I miss GOTO. It was unnecessarily expunged from the
Vintage> programmmer's toolbox by elitist academics.
Last I looked it was still alive and well; I just used it in a C++
program a few weeks ago.
That was the first time in many years -- on this topic I agree with
Dijkstra. But I don't believe he ever advocated not using it ever,
only that it should be avoided when there's a better answer, which is
in about 99% of the cases, but not 100%.
paul
1:18 p.m.
On Wed, 11 May 2005, Paul Koning wrote:
Right. But the way it's taught generally (at least in my experience and
observation) is that you should expend an hour of thinking and 10 lines of
code development rather than use a simple GOTO which would suffice quite
nicely and be more logical and readable.
--
Sellam Ismail Vintage Computer Festival
------------------------------------------------------------------------------
International Man of Intrigue and Danger http://www.vintage.org
[ Old computing resources for business || Buy/Sell/Trade Vintage Computers ]
[ and academia at www.VintageTech.com || at http://marketplace.vintage.org ]
>>>> "Vintage" == Vintage Computer Festival <vcf at
siconic.com> writes:
Vintage> I miss GOTO. It was unnecessarily expunged from the
Vintage> programmmer's toolbox by elitist academics.
Last I looked it was still alive and well; I just used it in a C++
program a few weeks ago.
That was the first time in many years -- on this topic I agree with
Dijkstra. But I don't believe he ever advocated not using it ever,
only that it should be avoided when there's a better answer, which is
in about 99% of the cases, but not 100%. 
11:45 p.m.
New subject: goat ooze [was mostly Re: Infocom on PDP-11]
[Paul Koning <pkoning at equallogic.com>]
[Jay West <jwest at classiccmp.org>]
That was the first time in many years -- on this topic
I agree with
Dijkstra. But I don't believe he ever advocated not using it ever,
only that it should be avoided when there's a better answer, which is
in about 99% of the cases, but not 100%.
[Vintage Computer Festival <vcf at siconic.com>]
That was the
first time in many years [...rest of above quote...]
Right. But the way it's
taught generally (at least in my experience
and observation) is that you should expend an hour of thinking and 10
lines of code development rather than use a simple GOTO which would
suffice quite nicely and be more logical and readable. I was preached to in college about not using [the
goto], but I still
did. For many years in professional life as well. But when I got
the C bug, I started conciously trying to keep it out of the other
languages I used. [...and it's been good...]
My position on the goto is that "don't use gotos" is a good thing to
teach students. As long as they are coders who need to rely on what
they're taught, they shouldn't use gotos, because they won't know when
to use them and when not to.
As with many other fields, you have to first learn the rules and fully
internalize them before you're good enough to know when it's okay to
break them.
Yes, I use gotos. Very occasionally. Except for throwing out of
nested functions in gcc, or when semi-mechanically translating labeled
control structure for use with compliers that don't have it, I can't
remember the last time I used one. (In neither use do I know of any
real alternative, though I do wish for an unwind-protect for the
former.)
/~\ The ASCII der Mouse
\ / Ribbon Campaign
X Against HTML mouse at rodents.montreal.qc.ca
/ \ Email! 7D C8 61 52 5D E7 2D 39 4E F1 31 3E E8 B3 27 4B
1:01 p.m.
At 10:12 AM 5/11/2005, Vintage Computer Festival wrote:
I miss GOTO. It was unnecessarily expunged from the
programmmer's toolbox
by elitist academics.
It's a tool. Why, I discussed this with a "Sam Ismail" back in 1999:
- John
Date: Fri, 15 Jan 1999 16:00:07 +0000
To: classiccmp at u.washington.edu, <dastar at ncal.verio.com>
From: John Foust <jfoust at threedee.com>
Subject: Re: Computers for children
At 11:37 PM 1/14/99 -0800, Sam Ismail wrote:
Remember, C has a goto statement, although I don't think in my nearly 10
years of C programming I've ever used it, although on certain rare
occasions it seemed the easy way out to a sticky coding problem.
[...] but C really suffers from a lack of
a general error trapping mechanism that one can invoke to break out of
loops as required. Sometimes I think goto's are the answer but I can
never find an appropriate way to implement it.
I use "goto" in C on a regular and consistent basis for error exceptions:
USHORT firstFunction( void )
{
USHORT lerr;
if ((lerr=secondFunction()) != TE_NOERROR) {
goto out;
}
out:
return lerr;
}
The benefit is that all functions propogate an error code, any
function can fail, and all functions clean up after themselves
after their "out" label.
- John
1:22 p.m.
On Wed, 11 May 2005, John Foust wrote:
At 10:12 AM 5/11/2005, Vintage Computer Festival
wrote:
This just goes to show how brainwashed I've become with regards to the use
of GOTO's ;)
I'm going to stick a GOTO into some code at an inappropriate place today
just to spite the Man!
--
Sellam Ismail Vintage Computer Festival
------------------------------------------------------------------------------
International Man of Intrigue and Danger http://www.vintage.org
[ Old computing resources for business || Buy/Sell/Trade Vintage Computers ]
[ and academia at www.VintageTech.com || at http://marketplace.vintage.org ]
I miss GOTO. It was unnecessarily expunged from
the programmmer's toolbox
by elitist academics.
It's a tool. Why, I discussed this with a "Sam Ismail" back in 1999:
9:17 p.m.
Vintage Computer Festival wrote:
I'm going to stick a GOTO into some code at an
inappropriate place today
just to spite the Man!
You'll spite yourself! Unnecessary GOTOs are JMPs and will empty your prefetch
queue (if your CPU has one :-)
--
Jim Leonard (trixter at oldskool.org) http://www.oldskool.org/
Want to help an ambitious games project? http://www.mobygames.com/
Or check out some trippy MindCandy at http://www.mindcandydvd.com/
5:45 p.m.
I especially like the rabbit command which requires the
multipunch of 12-3-7-8 along with the rabbit ears (") and
tail (.).
Okay, so I went and read the Intercal manual again, it was
a very nice diversion for this particular afternoon.
Also remember to code PLEASE when doing assignments.
jim
woodelf wrote:
Real programers use 'Come from' :D
10:37 p.m.
On Wed, 11 May 2005, Vintage Computer Festival wrote:
I miss GOTO. It was unnecessarily expunged from the
programmmer's toolbox
by elitist academics.
Most particularly Dijkstra.
But you might enjoy some of his other statements, such as:
<QUOTE>
FORTRAN --"the infantile disorder"--, by now nearly 20 years old, is
hopelessly inadequate for whatever computer application you have in mind
today: it is now too clumsy, too risky, and too expensive to use.
PL/I --"the fatal disease"-- belongs more to the problem set than to the
solution set.
It is practically impossible to teach good programming to students that
have had a prior exposure to BASIC: as potential programmers they are
mentally mutilated beyond hope of regeneration.
The use of COBOL cripples the mind; its teaching should, therefore, be
regarded as a criminal offence.
APL is a mistake, carried through to perfection. It is the language of the
future for the programming techniques of the past: it creates a new
generation of coding bums.
</QUOTE>
11:04 p.m.
It was thus said that the Great Fred Cisin once stated:
Most particularly Dijkstra.
But you might enjoy some of his other statements, such as:
<QUOTE>
FORTRAN --"the infantile disorder"--, by now nearly 20 years old, is ...
PL/I --"the fatal disease"-- belongs more to the problem set than ...
The use of COBOL cripples the mind; its teaching should, therefore, ...
APL is a mistake, carried through to perfection. It is the language ...
</QUOTE>
Um ... what language *did* he like then?
-spc (Let me guess ... Lisp?)
12 May
12 May
12:01 a.m.
> Most particularly Dijkstra.
> But you might enjoy some of his other statements, such as:
> <QUOTE>
> FORTRAN --"the infantile disorder"--, by now nearly 20 years old, is ...
> PL/I --"the fatal disease"-- belongs more to the problem set than ...
> The use of COBOL cripples the mind; its teaching should, therefore, ...
> APL is a mistake, carried through to perfection. It is the language ...
> </QUOTE>
On Wed, 11 May 2005, Sean 'Captain Napalm' Conner
wrote:
Um ... what language *did* he like then?
-spc (Let me guess ... Lisp?)
I'm going to guess Pascal
12:09 a.m.
Um ... what
language *did* he like then?
-spc (Let me guess ... Lisp?)
I'm going to guess Pascal
12:27 a.m.
> > Um ... what language *did* he like then?
> > -spc (Let me guess ... Lisp?)
>
> I'm going to guess Pascal
On Wed, 11 May 2005, Cameron Kaiser wrote:
program lart(yo, mama);
begin;
writeln('You had best not be dissing Pascal, boy');
end.
{ ;) }
Of course not. Just going by the fact that it is a lot harder to write a
FORTRAN program in Pascal than in most other languages. (and you didn't
use any form of GOTO)
OB_OT: My previous dog was named 'Pascal'. Current dog is 'Mac'
9:25 a.m.
>>>> "Sean" == Sean Conner
<spc at conman.org> writes:
Sean> It was thus said that the Great Fred Cisin once stated:
> Most particularly Dijkstra.
>
> But you might enjoy some of his other statements, such as:
>
> <QUOTE> FORTRAN --"the infantile disorder"--, by now nearly 20
> years old, is ... PL/I --"the fatal disease"-- belongs more to
> the problem set than ... The use of COBOL cripples the mind; its
> teaching should, therefore, ... APL is a mistake, carried through
> to perfection. It is the language ... </QUOTE>
Sean> Um ... what language *did* he like then?
Algol 60. After all, he was involved in its creation. Then again,
his later work was done in a paper language, somewhat Algol-like but
without the quirks. It would be an interesting classroom project to
create a formal grammar and compiler for that.
But not Algol 68. I once made the mistake of mentioning Algol 68 to
him. I got an earful. I think it took me half an hour to extricate
myself from that one...
paul
11:09 a.m.
At 11:04 PM -0400 5/11/05, Sean 'Captain Napalm' Conner wrote:
It was thus said that the Great Fred Cisin once
stated:
No, I believe that was around the time he was pushing Modula-2 as a
teaching tool.
I saved that SIGPlan Notices issue too as I really enjoyed those
quotes. Think Intel would pay $5K for that?
John
Most particularly Dijkstra.
But you might enjoy some of his other statements, such as:
<QUOTE>
FORTRAN --"the infantile disorder"--, by now nearly 20 years old, is ...
PL/I --"the fatal disease"-- belongs more to the problem set than ...
The use of COBOL cripples the mind; its teaching should, therefore, ...
APL is a mistake, carried through to perfection. It is the language ...
</QUOTE>
Um ... what language *did* he like then?
-spc (Let me guess ... Lisp?)
11 May
11 May
2:38 p.m.
At 12:10 AM 5/11/2005, Tom Jennings wrote:
> As far as sophistication goes -- a better measure than simply how
> clever or nifty a thing is -- how far did it advance the state of
> the art? Good Algol's in the early 1960's look like stuff robbed
> from the far-flung future. [...]
> Algol had it's share of horrors, but man it is the basis for
> nearly all modern languages.
On Wed, 11 May 2005, John Foust wrote:
Links for the intrigued... the report:
http://www.masswerk.at/algol60/report.htm
and an implementation for MS-DOS and CP/M, with source examples:
http://www.angelfire.com/biz/rhaminisys/algol60.html
Speaking as that voice from the future, reading ALGOL
makes
me say "You don't want to do it that way." GOTO had not yet
been exorcised. Did I see a computed goto, where the expression
calculates the label? Eeek.
Oh yeah, it has !TERRIBLE! features in it! Computed gotos are one
of the more amusing, and some of the side effects of it are just
plain bizarre.
But the scoping, for example, is pretty well accepted, though
Algol had some strange features, such as visibility of names in
blocks "upward" (I think it is).
I'm not claiming algol to be superior in any way (one item though,
dynamic evaluation is pretty neat), I'm not a 'in the past,
everything was better! TTL > CMOS!' person, specifically I was
observing that as a change/improvement in the then-current
state-of-the-art, Algol was the most successful failed language
ever.
(Computing program labels, as a floating number, with automatic
conversion to integer before execution, has got to one-up the IBM
FORTRAN 3-way branch on the silliness list. At least that fit a
hardware feature.)
But you have to feel for the poor bastards, trying to work out
these issues where you don't even have a character mapping you can
rely on. All the quoting/escaping bizarreness, that the unix Algol
interpreter a60 supports. Ugh.
Certainly it was a step forward,
but we've also learned a lot since then. When people complain
that computer languages haven't changed much, remind them
of the stuff that's fallen out of recommended practice.
6:14 p.m.
At 01:38 PM 5/11/2005, Tom Jennings wrote:
Oh yeah, it has !TERRIBLE! features in it! Computed
gotos are one
of the more amusing, and some of the side effects of it are just
plain bizarre.
The inverted syntax of "goto 60 if expression" was another
that caught my eye; it certainly reproduced in BASIC+ and today
still lives in Perl for the same ancestral reasons.
But you have to feel for the poor bastards, trying to
work out
these issues where you don't even have a character mapping you can
rely on. All the quoting/escaping bizarreness, that the unix Algol
interpreter a60 supports. Ugh.
One of the aforementioned references points out that Algol preceded
ASCII and influenced its development. At one point, they wanted
'do' and other keywords to be their own character (!) so you
could have 'do' as a variable name?
Algol, of course, lives on in Algore, an early supporting
component of the Internet.
- John
9:08 a.m.
>>>> "John" == John Foust
<jfoust at threedee.com> writes:
John> At 01:38 PM 5/11/2005, Tom Jennings wrote:
> Oh yeah, it has !TERRIBLE! features in it!
Computed gotos are one
> of the more amusing, and some of the side effects of it are just
> plain bizarre.
John> The inverted syntax of "goto 60 if expression" was another that
John> caught my eye;
??? There isn't any such syntax in Algol. Maybe you misread a
statement that had a conditional expression in it -- the Algol
predecessor to what in C is (foo<0) ? 1 : 2 -- but without the
unnecessary different tokens.
> But you have to feel for the poor bastards, trying
to work out
> these issues where you don't even have a character mapping you can
> rely on. All the quoting/escaping bizarreness, that the unix Algol
> interpreter a60 supports. Ugh.
John> One of the aforementioned references points out that Algol
John> preceded ASCII and influenced its development. At one point,
John> they wanted 'do' and other keywords to be their own character
John> (!) so you could have 'do' as a variable name?
You seem to be talking about APL. Algol 60 has keywords distinct from
variable names, but doesn't say how to implement that. Some
implementations have used quoting, some have used reserved words. In
Algol 68, that issue was addressed explicitly rather than left
unanswered.
I don't see how Algol 60 had anything to do with ASCII. Certainly the
ASCII character set (never mind the early versions) don't match what
the Algol 60 spec uses -- things like the sign for <= or for boolean
equivalence or "not" didn't show up in standard character sets until
Unicode.
paul
13 May
13 May
1:44 a.m.
On Thu, 12 May 2005, Paul Koning wrote:
The algol designers were very careful here; it's one of the better
things they did (though it was also their undoing since it messed
up source portability (a holy grail).
Algol had *three* formal specifications, I forget what they were
called precisely, but in essence:
1. the language description, in Backus-Naur and prose.
2. The reference language (exact phrase).
3. The implemented language (not exact).
1. is obvious. 2 is an "idealized" language with a glyph for each
language component; for example:
if x < y then begin;
...
end;
"<" is a unique glyph of course, and one of the now-standard ASCII
characters; but Algol specified one for less than,
less-than-equal, divide, modulo, multiply, etc, in traditional
mathematician culture. It was stated that the glyphs/symbols used
had no particular implementation value and represented only their
meaning(s) within the language (eg. < means arithmetic less-than).
The reference language used these and was referred to as an
idealization of an implementation.
It was up to the implementors to choose parsable
characters/sequences in the local character set (back when every
machine had its own character set). I doubt any actual computer
had a character code/set with enough unique glyphs to match the
reference language; it was assumed that there would be
multi-charater mappings (I think). This was very smart. This is
how things like "<=" came about.
I vaguely remember references somewhere to implementation issues
on really small character sets (like ITA2).
It was a tough world, they made some good decisions, and some
laughably bad ones.
John> The inverted syntax of "goto 60 if
expression" was another that
John> caught my eye;
??? There isn't any such syntax in Algol. Maybe you misread a
statement that had a conditional expression in it -- the Algol
predecessor to what in C is (foo<0) ? 1 : 2 -- but without the
unnecessary different tokens.
There are some severe umm let's say non-linearities in the
conditional expression evaluation; the algol60 spec "explains" it
but I found it extremely hard to follow -- it allows things that
are very, very non-obvious 'if if ... then then' type things;
clearly not that but things equally weird. I forget and am too
lazy to look up.
> But you
have to feel for the poor bastards, trying to work out
> these issues where you don't even have a character mapping you can
> rely on. All the quoting/escaping bizarreness, that the unix Algol
> interpreter a60 supports. Ugh.
John> One of the aforementioned references points out that Algol
John> preceded ASCII and influenced its development. At one point,
John> they wanted 'do' and other keywords to be their own character
John> (!) so you could have 'do' as a variable name?
You seem to be talking about APL. Algol 60 has keywords distinct from
variable names, but doesn't say how to implement that. Some
implementations have used quoting, some have used reserved words. In
Algol 68, that issue was addressed explicitly rather than left
unanswered.
I don't see how Algol 60 had anything to do with ASCII. Certainly the
ASCII character set (never mind the early versions) don't match what
the Algol 60 spec uses -- things like the sign for <= or for boolean
equivalence or "not" didn't show up in standard character sets until
Unicode.
11 May
11 May
9:34 a.m.
>>>> "Tom" == Tom Jennings
<tomj at wps.com> writes:
>> For that matter, Algol had local variables
long before C was
>> invented, and as you pointed out, there's an Algol for the PDP-8.
>> (Then again, that's not a true compiler -- it compiles to an
>> intermediate form that looks very much like a subset of the
>> Burroughs 5500 instruction set.)
> Using an IL was a way of making the complier easier I'd guess.
> Compiler deign has become more sophisticated since.
Tom> I dunno about that. I just read (and worked out on paper)
Tom> Randell's 1964 ALGOL IMPLEMENTATION book. Algol had(has) stuff
Tom> no (or few) language has today, like runtime evaluation of
Tom> stacked dynamic arguments.
You mean "call by name". Indeed. That's one of several Algol 60
features that were subsequently recognized as mistakes, and never
repeated. (Label assignment is another; I forgot the correct term.)
Tom> As far as sophistication goes -- a better measure than simply
Tom> how clever or nifty a thing is -- how far did it advance the
Tom> state of the art? Good Algol's in the early 1960's look like
Tom> stuff robbed from the far-flung future. A lot of the "compilers"
Tom> from that era we'd today call p-code interpreters (terminology
Tom> changes) but man, Algol60 is neat stuff. (Not the bloated
Tom> monster Algol68 (I think it was) became.
Then again, Algol 68 is the source of many C++ features -- iostreams
for example.
Let's see, Algol 60 brought us:
- Formal grammars (BNF)
- Block structure
- Local variables
- Scope of names
- Declarations
- Type safety
and indirectly
- structured programming
- parser generators
Tom> The Whetsone Algol compiler ran, in one pass, as fast as the
Tom> source-input reader hardware, in 7000 words of memory! Though
Tom> slow, it's a full-featured language, unlike C which is basically
Tom> a portable assembler (I loved writing in C).
I don't know how big the first Algol 60 compiler (at MC Amsterdam) was
-- probably similar, quite possibly smaller.
Tom> Algol had it's share of horrors, but man it is the basis for
Tom> nearly all modern languages. C's block and scope structure came
Tom> directly from Algol.
Lobotomized, of course -- C left out a bunch of important parts from
the Algol block structure.
Tom> Python's objects (the best done of any
Tom> language I've used, I hate to admit, since I find the python
Tom> culture utterly hideous) are directly analogous to the
Tom> Whetstone's scoping -- hell you could put OO structure into the
Tom> Whetstone compiler without ruining it!
Hm. Algol 60 certainly has no OO nature. Algol 68 does, the
beginnings of it.
paul
10:34 a.m.
Then again, Algol 68 is the source of many C++
features -- iostreams
for example.
Let's see, Algol 60 brought us:
- Formal grammars (BNF)
- Block structure
- Local variables
um, Fortran's variables were local - but
only local or global (Common) - nothing in between
- Scope of names
- Declarations
make that Mandatory declarations ... and even there the
predecessors of
COBOL were earlier
- Type safety
and indirectly
- structured programming
everybody has their own definition of structured
programming ...
- parser generators
Tom> The Whetsone Algol compiler ran, in one pass, as fast as the
Tom> source-input reader hardware, in 7000 words of memory! Though
Tom> slow, it's a full-featured language, unlike C which is basically
Tom> a portable assembler (I loved writing in C).
Tho' those 7000 words
were 48-bit (on the KDF9). The ICT/ICL1900 series
had an Algol (subset) that ran on a 4K (24-bit word) computer and a full
compiler for an 8K machine ... I can't remember, but I think the #XALE
(disk compiler) and #XALM (corresponding tape-based compiler) were for
16K. I think, also, that IBM's Algol compiler was an "E" code so
intended for a 32KB '360 ... not that the PL/I E compiler would run on that
size machine :-(
I don't know how big the first Algol 60 compiler (at MC Amsterdam) was
-- probably similar, quite possibly smaller.
Tom> Algol had it's share of horrors, but man it is the basis for
Tom> nearly all modern languages. C's block and scope structure came
Tom> directly from Algol.
Lobotomized, of course -- C left out a bunch of important parts from
the Algol block structure.
Some because C is really from the Fortran tradition
(Dirty tricks are
sometimes useful and too strong typing and structure prevent such); some
because they had been discovered to be more problematic than helpful.
Algol 60 -> CPL -> BCPL -> B -> C (importing much from PL/I* ... which
was a union of concepts from Algol 60, Fortran IV, and COBOL using
Algol structure)
* this linkage is not normally recognised in histories of programming
languages, but when it is considered that the originators of C had been
involved in the Multics project ... an OS written in PL/I; the only
previous production OS that had been written in a HLL was that of the
Burroughs machines ... using a version of Algol (to complete the
circularity of these references).
Hm. Algol 60 certainly has no OO nature. Algol 68
does, the
beginnings of it.
Simula 67 was a derivative of Algol 60 that is normally recognised as the
foundation of OO.
Andy
--
Internal Virus Database is out-of-date.
Checked by AVG Anti-Virus.
Version: 7.0.308 / Virus Database: 266.11.5 - Release Date: 04/05/05
10:48 a.m.
Andy Holt wrote:
The PDP-7 with 8K of memory had a major impact on what B had for features.
Only with >8K of memory on the PDP-11 could you get a real compiler.
> Tom> The Whetsone Algol compiler ran, in one
pass, as fast as the
> Tom> source-input reader hardware, in 7000 words of memory! Though
> Tom> slow, it's a full-featured language, unlike C which is basically
> Tom> a portable assembler (I loved writing in C).
>
>
But remember too you really had only two sized variables, ints and
floating point.
I think the big problem with algol you never were ment to compile it,
just write
programns in it. 8K words are ample for a language that does not have
character
data. 32KB seems to be the smallest size a character orientated language
like C or Pascal.
Also most machines had built in floating point so the run time size was
small
I don't
know how big the first Algol 60 compiler (at MC Amsterdam) was
-- probably similar, quite possibly smaller.
Tom> Algol had it's share of horrors, but man it is the basis for
Tom> nearly all modern languages. C's block and scope structure came
Tom> directly from Algol.
Lobotomized, of course -- C left out a bunch of important parts from
the Algol block structure.
Some because C is really from the Fortran tradition (Dirty tricks are
sometimes useful and too strong typing and structure prevent such); some
because they had been discovered to be more problematic than helpful.
Algol 60 -> CPL -> BCPL -> B -> C (importing much from PL/I* ... which
was a union of concepts from Algol 60, Fortran IV, and COBOL using
Algol structure)
* this linkage is not normally recognised in histories of programming
languages, but when it is considered that the originators of C had been
involved in the Multics project ... an OS written in PL/I; the only
previous production OS that had been written in a HLL was that of the
Burroughs machines ... using a version of Algol (to complete the
circularity of these references).
Hm. Algol 60
certainly has no OO nature. Algol 68 does, the
beginnings of it.
Simula 67 was a derivative of Algol 60 that is normally recognised as the
foundation of OO.
Andy
--
Internal Virus Database is out-of-date.
Checked by AVG Anti-Virus.
Version: 7.0.308 / Virus Database: 266.11.5 - Release Date: 04/05/05
.
11:09 a.m.
>>>> "woodelf" == woodelf
<bfranchuk at jetnet.ab.ca> writes:
woodelf> But remember too you really had only two sized variables,
woodelf> ints and floating point. I think the big problem with algol
woodelf> you never were ment to compile it, just write programns in
woodelf> it.
Nonsense. It certainly wasn't designed as a paper language, and it
wasn't used as a paper language. The first compiler (MC Amsterdam, by
Dijkstra) was a real compiler, and at the T.U. Eindhove the "THE"
operating system used Algol exclusively, so all the programming for
many years at that major university was done in Algol 60.
paul
2:43 p.m.
On Wed, 11 May 2005, Paul Koning wrote:
Hm. Algol 60 certainly has no OO nature. Algol 68
does, the
beginnings of it.
I don't mean to imply anyone in 1964 saw this, I'm only saying
after looking at the compiler design it seemed 'obvious' to me
language extentions to accomodate scope at the top level could fit
without ruining it.
7011
days inactive
7015
days old
33 comments
16 participants
participants (16)
-
ajp166＠bellatlantic.net -
andyh＠andyh-rayleigh.freeserve.co.uk -
bfranchuk＠jetnet.ab.ca -
cisin＠xenosoft.com -
dundas＠caltech.edu -
frustum＠pacbell.net -
jfoust＠threedee.com -
jwstephens＠msm.umr.edu -
kth＠srv.net -
mouse＠Rodents.Montreal.QC.CA -
pkoning＠equallogic.com -
spc＠conman.org -
spectre＠floodgap.com -
tomj＠wps.com -
trixter＠oldskool.org -
vcf＠siconic.com