21 Mar
2007
21 Mar
'07
8:12 a.m.
Date: Tue, 20 Mar 2007 09:33:54 -0700
From: "Chuck Guzis" <cclist at sydex.com>
Subject: Re: John Backus passes away...
Considering FORTRAN for what it was when it came out, it was pretty
remarkable. I recall an old ACM (was it SIGPLAN?) recollection of
one of the first users of 704(?) FORTRAN. What impressed me was that
this compiler-on-cards pointed out a syntax error with message of the
form:
A COMPUTED GOTO REQUIRES A COMMA BETWEEN THE STATEMENT LIST AND
VARIABLE. E.G. GOTO (100,200,300),J
I used Fortran 4 on the IBM 7094 at Imperial College London. I
remember one day the
compiler reported:
FORMAT MISSPELLED ON LINE xxx FORMAT ASSUMED.
I was used to syntax error messages by the dozen but this was the
first time I had
seen the compiler correct an error and run the job. Of course we are
used to
warnings now, but I think it was that one which got me interested
enough in
compilers to eventually get a job writing them.
At one point in time, given machines with different
character sets
and word- and character sizes, FORTRAN was about the only way to
write a portable program. If the program involved, for instance,
text manipulation, one included as the first card of the data file
one punched with all of the characters of the alphabet to be used and
read it into an integer array using 80A1 format.
If you stuck to floating point and small numbers but there were big
problems
with word length variations when using integers.
Did any computer built after 1960 NOT have a FORTRAN implementation?
Yes, my ICT1301 (155+ built from 1962 to 1965) had no Fortran compiler.
But then the line printer did not have any sort of parentheses. Not ()
[] or {}.
It had 1/4,1/2 and 3/4 though. I have a replacement print barrel with
round brackets instead if the 1/4 and 3/4 symbols but I have not
fitted it
yet, and most 1300 series machines had the standard barrel.
I seem to remember that some of the people who taught me to program
considered Fortran to be too close to the 7094 instruction set, in
particular
they said the computed goto mapped directly onto a 7094 instruction and
hence considered it to be not very universal, and to support it would
be to
assist IBM in its domination of the computer market.
Not that I think that way, and of course it is Microsoft which now
dominates
the computer market, I haven't seen a new IBM machine in years.
IIRC, that was a big selling point for the PDP-8.
There was a period in time where just about any serious programmer
had a copy of McCracken on their bookshelves.
Maybe before my time (BSc Computer Science graduated 1974), but I
think most serious programmers had a copy of Knuth vol 1. (not to open
a thread on what defines a "real programmer", I expect that has been
done to death on this list long before I joined it).
Didn't Backus also participate in the Algol-60 effort?
I don't know, but Algol 60 was defined using BNF.
There were big sections of the CDC FTN compiler (prior to the
introduction of SYMPL) that were written in FORTRAN. One of the
biggest nightmares was the processor for allocating storage in COMMON
and EQUIVALENCE statements--a big mass of assigned GOTOs. Even after
I understood how it worked, I was afraid to touch it.
On the subject of being afraid to touch code, I worked on a compiler
written
in a non recursive language (Coral 66, a real time language derived from
Algol 60). It had a large data table which defined how to parse the
language.
The compiler had an array of integers which was really a stack, but
instead
of return addresses it had integers which referred to cases in a huge
switch
list. I was happy to change any of the code, but fortunately did not
need to
change the data table for a long long time, and when I did it was with
EXTREME care and trepidation.
21 Mar
21 Mar
1:17 p.m.
On 21 Mar 2007 at 12:12, Roger Holmes wrote:
I used Fortran 4 on the IBM 7094 at Imperial College
London. I
remember one day the compiler reported:
I used FORTRAN II under FMS II on the 7090 but never saw a FORTRAN IV
implementation there. It's been entirely too long ago, but, as I
recall, one punched a "B" in column 1 for boolean expressions, "D"
for double-precision and "I" for complex, as FORTRAN II still relied
on implicit typing for variables.
One of the most diagnostic-bald versions of FORTRAN I ever used was
the "USA BASIC FORTRAN" under DOS/360. The thing couldn't have had
more than about 10 diagnostic messages, most of them single-word.
I was used to syntax error messages by the dozen but
this was the
first time I had seen the compiler correct an error and run the job. Of
course we are used to warnings now, but I think it was that one which
got me interested enough in compilers to eventually get a job writing
them.
Pat could probably fill in details here, but Purdue for many years
used 7090/94's to run a student variant of FORTRAN called PUFFT. The
basic idea was for the compiler to 'fix" as many errors as possible
so that a program would run somehow. I believe it was described by
Saul Rosen in an ACM paper and republished in one of those
"Programming Languages Survey" books. IIRC, the 709x were also used
as I/O front ends for the CDC 6600 there, which ran Purdue's own
variant of MACE, rather than the more-or-less standard SCOPE. Greg
Mansfield was pretty proud of that.
If you stuck to floating point and small numbers but
there were big
problems with word length variations when using integers.
IIRC, the 32-bit floating point word (with 4-bit normalization
granularity) of S/360 cost IBM a bunch of business in the
"scientific" world. It had one of the lowest-precision FP
representation of big iron at the time. I believe that IBM
eventually remedied this with "extended precision".
I seem to remember that some of the people who taught
me to program
considered Fortran to be too close to the 7094 instruction set, in
particular they said the computed goto mapped directly onto a 7094 instruction and
hence considered it to be not very universal, and to support it would be to
assist IBM in its domination of the computer market.
That must have been some clever propganda on the part of someone!
But conspiracy theories have always been popular. Computed GOTOs
weren't exactly the dominant feature of most programs--and they were
implemented as simple indexed jumps for the most part--a feature
scarcely unique to IBM hardware!
For small systems, FORTRAN was amazingly useful. The other day, I
ran across some code that I wrote for CP/M to convert between ISIS-II
and CP/M file formats--in FORTRAN.
Compiler design has come a long way since. In the 1970's, I recall
that a co-worker pushed a PTR in front of my face that was, frankly,
quite surprising. CDC FTN for years allowed an alternative way of
expressing Hollerith constants using any arbitrary delimiter
character, so 5HCHUCK and H*CHUCK* were equivalent ways of expressing
the same constant. Most people used asterisks or the not-equal
symbol (the standard character set didn't have quotation marks), but
the compiler would allow just about anything.
The statement in question looked something like this:
100 FORMAT( HX)=(1+BX )
Recall, that prior to FORTRAN 90, FORTRAN had no reserved words.
Cheers,
Chuck
8:17 p.m.
Did any
computer built after 1960 NOT have a FORTRAN implementation?
Yes, my ICT1301 (155+ built from 1962 to 1965) had no Fortran compiler. I seem to remember that some of the people who taught
me to program
considered Fortran to be too close to the 7094 instruction set, in
particular
they said the computed goto mapped directly onto a 7094 instruction and
hence considered it to be not very universal, and to support it would
be to
assist IBM in its domination of the computer market.
THe story I heard was that as computer time was so expensive back then
(while human programmer time was relatively cheap), had the Fortran
compiler not gernerated code that was as efficient as a reasonable
programmer's hand-genearted code then nobody would use Fortran.
Making the Fortran language clsoe to the target machine's instruction set
would certainly make it wasier for a relatively simple compiler to
generate efficient code.
-tony
9:41 p.m.
On 22 Mar 2007 at 0:17, Tony Duell wrote:
I've not seen a Fortran compiler for any of the following :
HP9830 (I claim this is a computer, it ran BASIC from ROM)
Philips P850 (maximum 2K words of core, I believe larger P800 series
machines did have a Fortran compiler available)
HP9825, 9831, 9845, 9835 series
HP80 series.
Just about all the pocekt computers (Sharp, Casio, HP, etc)
What abotu the IBM 5100? And for that matter the Commodore PET (I know
the SuperPET had such a compiler), the C64, etc. And the Sinclair/Amstrad
machines (ZX*0, ZX81, Spectrums). And the Oric
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted.
A few of those that you've cited simply didn't have the resources for
it.
But maybe not--even the lowly IBM 1620 with 20K digits (not bytes--a
character took 2 digits) of core and no disk drive would compile
FORTRAN. That's pretty remarkable when you consider that a 1620
instruction is 12 digits long--and the bottom half-K or so was
dedicated to storing arithmetic lookup tables (the 1620 Cadet
couldn't even add two numbers without the tables first being loaded).
The card reader-punch was used as intermediate storage--you read in
pass 1 of the compiler, then your program, which caused a new card to
be punched for every statement. You then read in the deck for pass
2, followed by your program and an executable object deck was punched
(and a listing was made on the printer). AFAIK, the Cadet equipped
with paper tape instead of cards could do the same thing.
Cheers,
Chuck
Did any computer built after 1960 NOT have a FORTRAN
implementation?
Yes, my ICT1301 (155+ built from 1962 to 1965) had no Fortran compiler. 
10:04 p.m.
On 3/21/07, Chuck Guzis <cclist at sydex.com> wrote:
On 22 Mar 2007 at 0:17, Tony Duell wrote:
There was a C compiler for the C-64. It was terrible and slow, but it
did do small programs. There were also BASIC compilers, but they
weren't terribly fashionable. Mostly folks programmed in interpreted
BASIC or assembler on those platforms (though there _was_ a push for a
while for a language named COMAL, but I avoided it).
I know there was a FORTRAN compiler for the SuperPET, but having not
used it, I have to ask what the available target CPUs were - 6809,
6502, or both?
With its banked 64Kbyte memory card, the SuperPET weighed in at 96K -
plenty of RAM for serious work, but the processors were still slow,
and IEEE disks with software GPIB handshake were no speed demons
either.
PETs were popular in some lab settings, so I would think that if
FORTRAN would have been available for it, there would have been a
niche market. Perhaps that's why the SuperPET had FORTRAN as an
option.
-ethan
... And for that matter the Commodore PET (I
know
the SuperPET had such a compiler), the C64, etc.
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted. 
10:45 p.m.
New subject: SuperPET (was: Re: John Backus passes away...)
I know there was a FORTRAN compiler for the SuperPET,
but having not
used it, I have to ask what the available target CPUs were - 6809,
6502, or both?
With its banked 64Kbyte memory card, the SuperPET weighed in at 96K -
plenty of RAM for serious work, but the processors were still slow,
and IEEE disks with software GPIB handshake were no speed demons
either.
PETs were popular in some lab settings, so I would think that if
FORTRAN would have been available for it, there would have been a
niche market. Perhaps that's why the SuperPET had FORTRAN as an
option.
The superpet was a joint development between Commodore and the University
of Waterloo here in Ontario - It was originally developed as a way to teach
mainframe languages (at the time) without having to have mainframes (This
is why it is sometimes referred to as the Micro-Mainframe).
The Waterloo software (including all the compiled languages) runs pretty
much independant of the 6502, using the original PET hardware just for I/O.
(In fact, the MicroWAT, a small stand-alone 6809 computer ram the Waterloo
languages without a 6502/PET board at all). There are no options to compile
code for the 6502.
It is very slow to use - but I suppose that wasn't a major problem for the
learning environment it was intended for - Most of the programs compiled
would be small, and it sure beat having to relocate to a mainframe shop.
I have two working SuperPETs, and I love them - not only do they have my
favorite 8-bit processor (6809), but also APL which I was fanatical about
when I first started "discovered computers" playing with the university
mainframe. Very cool machines!
Dave
--
dave06a (at) Dave Dunfield
dunfield (dot) Firmware development services & tools: www.dunfield.com
com Collector of vintage computing equipment:
http://www.classiccmp.org/dunfield/index.html
22 Mar
22 Mar
10:23 a.m.
New subject: SuperPET (was: Re: John Backus passes away...)
On 21/03/07, Dave Dunfield <dave06a at dunfield.com> wrote:
> I know there was a FORTRAN compiler for the
SuperPET, but having not
> used it, I have to ask what the available target CPUs were - 6809,
> 6502, or both?
> PETs were popular in some lab settings, so I
would think that if
> FORTRAN would have been available for it, there would have been a
> niche market. Perhaps that's why the SuperPET had FORTRAN as an
> option.
My SuperPET once served as a controller for Lab equipment in the
Physics dept. at McGill, but I'm fairly certain it was in the 6502
mode (likely BASIC, even). Basic acquisition using the IEEE-488 port,
actual processing was probably done on bigger irons.
The Waterloo software (including all the compiled
languages) runs pretty
much independant of the 6502, using the original PET hardware just for I/O.
(In fact, the MicroWAT, a small stand-alone 6809 computer ram the Waterloo
languages without a 6502/PET board at all). There are no options to compile
code for the 6502.
IIRC, (and I do intend to check soon - cleaning and powering up my
SP9000 is a task for this spring :-) the languages are not actually
compiled - it's interpreted.
It is very slow to use - but I suppose that wasn't
a major problem for the
learning environment it was intended for - Most of the programs compiled
would be small, and it sure beat having to relocate to a mainframe shop.
I have two working SuperPETs, and I love them - not only do they have my
favorite 8-bit processor (6809), but also APL which I was fanatical about
when I first started "discovered computers" playing with the university
mainframe. Very cool machines!
Yes, it's the APL which really makes the machines special. We don't
need no stinkin' bit-mapped display! We have custom character sets!
(I think I still have the sheet with the sticky APL keycaps - though
they are actually in the front of the key - invaluable unless you can
touch type funky greek characters!)
BTW Dave, I also have a second copy of WordPro (or whatever it's
called?) with full manual, if you're interested. With ROM, even... I
guess some grad students even used it to write their theses! No I
don't know why two copies came with one PET, I guess a second PET
burnt out at some point.
Joe.
21 Mar
21 Mar
11:01 p.m.
... And for that matter the Commodore PET (I know
the SuperPET had such a compiler), the C64, etc.
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted. 
22 Mar
22 Mar
8:49 a.m.
And thusly were the wise words spake by Ethan Dicks
On 3/21/07, Chuck Guzis <cclist at sydex.com> wrote:
Commodore also released PILOT for the C-64..
Cheers,
Bryan
On 22 Mar 2007 at 0:17, Tony Duell wrote:
There was a C compiler for the C-64. It was terrible and slow, but it
did do small programs. There were also BASIC compilers, but they
weren't terribly fashionable. Mostly folks programmed in interpreted
BASIC or assembler on those platforms (though there _was_ a push for a
while for a language named COMAL, but I avoided it).
... And for that matter the Commodore PET (I
know
the SuperPET had such a compiler), the C64, etc.
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted.
10:59 a.m.
> > How many of the above would run *any* type
of compile-to-machine-
> > language HLL compiler? Most of the BASICs were tokenized and
> > interpreted.
> There was a C compiler for the C-64.
Commodore also released PILOT for the C-64..
It's only an interpreter, though, alas. But I like PILOT and the C64 version
had some interesting extensions.
--
--------------------------------- personal: http://www.armory.com/~spectre/ ---
Cameron Kaiser * Floodgap Systems * www.floodgap.com * ckaiser at floodgap.com
-- jsr $fce2 ------------------------------------------------------------------
9:55 a.m.
Ethan Dicks wrote:
On 3/21/07, Chuck Guzis <cclist at sydex.com>
wrote:
I used one of those compilers. What a piece of cr at p.
It compiled at run time only, like Alice Pascal, and was terribly slow. The
copy protected/write protected compiler disk had to be in the drive while the
program was running. I don't recall it being possible to save programs to
another disk.
It took five minutes to compile "hello world"
It could only be useful to learn something about C.
Assembler was more fun. Especially when playing with self-modifying code.
--
jd
Don't take life so serious, son, it ain't nohow permanent.
-- Walt Kelly
On 22 Mar 2007 at 0:17, Tony Duell wrote:
There was a C compiler for the C-64. It was terrible and slow, but it
did do small programs. There were also BASIC compilers, but they
weren't terribly fashionable. Mostly folks programmed in interpreted
BASIC or assembler on those platforms (though there _was_ a push for a
while for a language named COMAL, but I avoided it).
... And for that matter the Commodore PET (I
know
the SuperPET had such a compiler), the C64, etc.
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted. 
21 Mar
21 Mar
10:37 p.m.
Chuck Guzis wrote:
But maybe not--even the lowly IBM 1620 with 20K digits
(not bytes--a
character took 2 digits) of core and no disk drive would compile
FORTRAN.
...
That's pretty impressive. I wonder which machine would take the prize for the
most done with so little? It's quite amazing how much could be squeezed out of
some of these old systems...
22 Mar
22 Mar
midnight
On 21 Mar 2007 at 21:37, Jules Richardson wrote:
That's pretty impressive. I wonder which machine
would take the prize for the
most done with so little? It's quite amazing how much could be squeezed out of
some of these old systems...
What was the minimum core requirement on a 360/20 for FORTRAN? Did
that include external mass storage?
Cheers,
Chuck
11:07 a.m.
Jules Richardson wrote:
Chuck Guzis wrote:
> But maybe not--even the lowly IBM 1620 with 20K digits (not bytes--a
> character took 2 digits) of core and no disk drive would compile
> FORTRAN.
>...
The really fun part was using "load and go fortran". As I recall (dimly),
you'd load the fortran deck and then load your fortran code. I'm pretty
sure it compiled into memory and then just ran it...
-brad
10:08 p.m.
On 22 Mar 2007 at 11:07, Brad Parker wrote:
> The really fun part was using "load and go
fortran". As I recall
(dimly),
you'd load the fortran deck and then load your
fortran code. I'm pretty
sure it compiled into memory and then just ran it...
My memory's a little dim, but without a 1311, (and hence an honest-to-
gosh operating system--sort of), I think you were pretty much
confined to loading the compiler, which immedately punched a loader
deck, then read your program and punched an object deck. You then
loaded the punched object deck with the subroutine deck and it ran.
I do remember the dreaded "OVERLAP" error--that and the 1622 mulching
the compiler deck.
Hey, it was barely FORTRAN, but it was FORTRAN!
Cheers,
Chuck
26 Mar
26 Mar
11:05 p.m.
Fred Cisin wrote:
On Thu, 22 Mar 2007, Chuck Guzis wrote:
Jerome Fine replies:
I don't have the time to compare FORTRAN IV and FORTRAN 77,
but I seem to have the feeling that I can use code in FORTRAN 77
that is completely acceptable in FORTRAN IV. Maybe not every
program can be compatible (especially DOUBLE PRECISION and COMPLEX),
but a simple demo program should probably be identical.
What I am saying is that if you don't use the extra features of
FORTRAN 77, then it will probably still feel like a real FORTRAN.
But then of course, why bother.
Now I understand that FORTRAN 90 is very different, but that seems
completely off-topic - well maybe not - when was FORTRAN 90
released?
In any case I am NOT attempting to contradict your feeling, just
suggesting that if you are going to use the newer features in
FORTRAN 77 (such as 32 bit INTEGER *4), then obviously it will
not feel link the original. Personally, since I have a strong
requirement for both INTEGER *8 and INTEGER *16 along with much
more memory, I am probably going to give serious attention to
shifting to current hardware - UNLESS I am able to integrate
E11 and a DLL called EMEM32.DLL which will provide that access.
If that works, I will be able to use what seems like a separate
CPU to access up to 2 GigaBytes of memory and the assembly
language instructions for short subroutines which I want to
implement to frequently execute certain short loops many, many
times (often trillions of times) without having the overhead of
re-entering the DLL for each separate execution of the loop.
Sincerely yours,
Jerome Fine
--
If you attempted to send a reply and the original e-mail
address has been discontinued due a high volume of junk
e-mail, then the semi-permanent e-mail address can be
obtained by replacing the four characters preceding the
'at' with the four digits of the current year.
Hey, it was barely FORTRAN, but it was FORTRAN!
I have fond memories of the good old days, with PDQ FORTRAN
It made you appreciate FORTRAN IV. (and WATFOR!)
But then Fortran 77 just didn't feel like a real FORTRAN.
27 Mar
27 Mar
2:51 a.m.
New subject: Fortran Versions (was JB Passes)
On 26 Mar 2007 at 22:05, Jerome H. Fine wrote:
I don't have the time to compare FORTRAN IV and
FORTRAN 77,
but I seem to have the feeling that I can use code in FORTRAN 77
that is completely acceptable in FORTRAN IV. Maybe not every
program can be compatible (especially DOUBLE PRECISION and COMPLEX),
but a simple demo program should probably be identical.
Sans vendor-specific extensions, you're probably right. At least
that was the goal of F77. I did a few X3J3 sessions with what was
then known informally as the FORTRAN 8x ANSI group (vector extensions
on behalf of ETA) and at least then (1985), the goal was to maintain
backward compatibility, albeit with quite a number of "deprecated"
features. It was a nasty experience with threats by the IBM
contingent to walk out of the proceedings.
A big argument was "Should X3J3 simply select the best of the current
extensions and ratify them or should we be about designing a new
language?" It was a serious issue; IBM wanted Vectran ratified; many
wanted an alternative syntax.
Needless to say, with all of the contention, FORTRAN 8x wasn't about
to meet the informal goal of becoming FORTRAN 88--it took until 1990--
and I'd been long gone.
Full-blown F90 looks about as much like F77 as F2003 looks like F90.
It's kind of like going back to the old neighborhood after 30 or 40
years--you recognize some things, but it's mostly foreign.
I rather liked Basic FORTRAN IV (that's what it was called). A
minimal functional subset; no logical IFs, ASSIGNed GOTOs, object-
time FORMAT or named COMMON. Just a handful of statements that you
could pretty much compile and run anywhere.
Cheers,
Chuck
3:59 p.m.
New subject: Fortran Versions (was JB Passes)
Chuck Guzis wrote:
I rather liked Basic FORTRAN IV (that's what it
was called). A
minimal functional subset; no logical IFs, ASSIGNed GOTOs, object-
time FORMAT or named COMMON. Just a handful of statements that you
could pretty much compile and run anywhere.
I rather liked full blown FORTRAN IV. I have been looking at
the PDP8 Fortran IV version and all things considered that was
a powerful machine for its price range in the 1970's.
All this talk of Fortran 77, 90 make fortran a more modern
langage but it seems to me they lost something in that the old
programs have to be re-written since they don't support things
like sence switches for example.
Cheers,
Chuck
6:49 p.m.
New subject: Fortran Versions (was JB Passes)
On 27 Mar 2007 at 12:59, woodelf wrote:
I rather liked full blown FORTRAN IV. I have been
looking at
the PDP8 Fortran IV version and all things considered that was
a powerful machine for its price range in the 1970's.
All this talk of Fortran 77, 90 make fortran a more modern
langage but it seems to me they lost something in that the old
programs have to be re-written since they don't support things
like sence switches for example.
The problem with "full blown" FORTRAN IV was the same as "full blown"
FORTRAN II and "full blown" FORTRAN--everyone had extensions--and
what the selfsame extensions did could vary wildly between vendors.
Some used the logical operators as bitwise booleans; e.g., C =
A.OR.B; there were optional arguments in I/O statement syntax,
additional FORMAT specifiers, etc. FWIW, I think that IBM FORTRAN IV
supported sense switches only through function calls. CDC 6000-
series machines didn't have sense switches (or blinkinlights) --
rather a location in low memory within the user's RA could be set
via operator command.
I seem to recall (this was a LONG time ago) that 7090 FORTRAN had
extensions that keyed off of what was punched in column 1. "D" meant
that the operators were double precision; "B" meant boolean, "I"
meant complex (IIRC).
The big problem with permissive-by-default vendor-unique extensions
is that it's just about impossible to keep programmers from using
them--and so make migration to a different vendor's platform more
difficult than it needs to be.
You haven't lived until you've worked on an RFP response that
addresses how you're going to handle another vendor's extension to a
supposedly "standard" language.
Didn't COBOL 75 mandate that the "standard" language contain no
vendor extensions unless specifically enabled? Again, it's been a
long time, but I seem to recall a something in that spirit. (COBOL
was even worse than FORTRAN when it came to vendor-unique features).
Cheers,
Chuck
7 p.m.
New subject: Fortran Versions (was JB Passes)
old programs have to be re-written since they
don't support
things like sence switches for example.
I suspect because the concept of a sense switch on a contemporary
machine is moot - there are no physical switches to toggle to signal a
change in the execution of a program.
How did newer versions of the language handle deprecation of the sense
switch - error, warning, ignore?
Lee Courtney
> -----Original Message-----
> From: cctalk-bounces at classiccmp.org
> [mailto:cctalk-bounces at classiccmp.org] On Behalf Of woodelf
> Sent: Tuesday, March 27, 2007 1:00 PM
> To: On-Topic and Off-Topic Posts
> Subject: Re: Fortran Versions (was JB Passes)
>
> Chuck Guzis wrote:
>
>
> > I rather liked Basic FORTRAN IV (that's what it was called). A
> > minimal functional subset; no logical IFs, ASSIGNed GOTOs, object-
> > time FORMAT or named COMMON. Just a handful of
> statements that you
> > could pretty much compile and run anywhere.
>
> I rather liked full blown FORTRAN IV. I have been looking at
> the PDP8 Fortran IV version and all things considered that
> was a powerful machine for its price range in the 1970's.
> All this talk of Fortran 77, 90 make fortran a more modern
> langage but it seems to me they lost something in that the
old programs have to be re-written since they
don't support
things like sence switches for example.
>
> > Cheers,
> > Chuck
>
>
>
28 Mar
28 Mar
2:21 a.m.
New subject: Fortran Versions (was JB Passes)
On 27 Mar 2007 at 16:00, Courtney, Lee wrote:
How did newer versions of the language handle
deprecation of the sense
switch - error, warning, ignore?
There's no reason why they can't be supported if you don't have
"real" sense switches. As I mentioned in a later message, sense
switches were supported on the CDC 6000 systems and there are no
sense switches, go buttons or even blinking lights that the operator
can get to after deadstart. However, the operator's console had
commands n.ONSW,x and n.OFFSW,x which toggled bits in a location
in low memory within control point "n"'s RA, which corresponded to
sense switches. I also believe that SCOPE and KRONOS/MACE both had
job control statements to do the same.
Cheers,
Chuck
27 Mar
27 Mar
4:41 p.m.
New subject: Fortran Versions (was JB Passes)
On Mon, 26 Mar 2007, Chuck Guzis wrote:
I rather liked Basic FORTRAN IV (that's what it
was called). A
minimal functional subset; no logical IFs, ASSIGNed GOTOs, object-
time FORMAT or named COMMON. Just a handful of statements that you
could pretty much compile and run anywhere.
I remember doing object-time FORMAT in about 1970 at George Washington
University on my father's faculty account. But, ... maybe that was in
WATFOR.
(I was printing out depth of focus tables for some lenses)
Yes, a real programmer can write a FORTRAN IV program in FORTRAN 77.
But, I was teaching it (1983), and besides my professional responsibility
to include the enhancements, some of my students liked to explore.
--
Grumpy Ol' Fred cisin at xenosoft.com
22 Mar
22 Mar
7:12 p.m.
> > > Did any computer built after 1960 NOT
have a FORTRAN implementation?
[My list of machines delected]
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted.
Sure. But the roiginal statement was 'any computer'. Not 'any computer
that suported a compiler for any language'.
Was there ever a Fortran for the HP9000/200 series machines? I'ev not
heard of one, but I'd be suprised if it didn't exist. They were aimed at
the scientific/laboratory market, they certainly had enough computer
power to run Fortran (8 MHZ 68000, 256K or more RAM), and they did
suppoer a pascal compiler.
-tony
24 Mar
24 Mar
5:42 a.m.
On Wed, 2007-03-21 at 18:41 -0700, Chuck Guzis wrote:
On 22 Mar 2007 at 0:17, Tony Duell wrote:
I've not seen a Fortran compiler for any of the following :
HP9830 (I claim this is a computer, it ran BASIC from ROM)
Philips P850 (maximum 2K words of core, I believe larger P800 series
machines did have a Fortran compiler available)
HP9825, 9831, 9845, 9835 series
HP80 series.
Just about all the pocekt computers (Sharp, Casio, HP, etc)
What abotu the IBM 5100? And for that matter the Commodore PET (I know
the SuperPET had such a compiler), the C64, etc. And the Sinclair/Amstrad
machines (ZX*0, ZX81, Spectrums). And the Oric
How many of the above would run *any* type of compile-to-machine-
language HLL compiler? Most of the BASICs were tokenized and
interpreted.
A few of those that you've cited simply didn't have the resources for
it.
There were a couple of different BASIC compilers for the ZX Spectrum.
Gordon
Did any computer built after 1960 NOT have a FORTRAN
implementation?
Yes, my ICT1301 (155+ built from 1962 to 1965) had no Fortran compiler.
21 Mar
21 Mar
11:03 p.m.
I've not seen a Fortran compiler for any of the
following :
:
What abotu [...] the C64, etc.
Abacus made a FORTRAN compiler for the 64. They even made a COBOL (!).
--
--------------------------------- personal: http://www.armory.com/~spectre/ ---
Cameron Kaiser * Floodgap Systems * www.floodgap.com * ckaiser at floodgap.com
-- Mmmm, Windows user. Crunchy and good with ketchup. -- Dave McGuire ---------
6321
days inactive
6328
days old
25 comments
16 participants
participants (16)
-
ard＠p850ug1.demon.co.uk -
bfranchuk＠jetnet.ab.ca -
bpope＠wordstock.com -
brad＠heeltoe.com -
cclist＠sydex.com -
cisin＠xenosoft.com -
dave06a＠dunfield.com -
ethan.dicks＠gmail.com -
gordon＠gjcp.net -
jhfinedp3k＠compsys.to -
joachim.thiemann＠gmail.com -
julesrichardsonuk＠yahoo.co.uk -
Lee.Courtney＠windriver.com -
onymouse＠garlic.com -
roger.holmes＠microspot.co.uk -
spectre＠floodgap.com