A while ago, a friend
made me aware of a neat new toy, a tiny credit card sized computer
which comes out of Britain with the weird name of “Raspberry
Pi”. Introduced early in 2012 it has become somewhat of a
phenomenon, the range of uses to which it has been put and the number
of sales, at $35 each, have way exceeding what its creators
expected. Although small, there are several OS's which will run
on it, most of a Linux descent, and with that compatibility, many tools
are freely available for it. If you want to know more, just
Google it.
Although most anything that
will run on Linux will work on the Pi, the language for which it was
developed was “Python”, named after the British TV comedy
series, “Monty Python's Flying Circus” (and thus
keeping in tune with the weird names aspect). An interpreted
language, it embodies the concepts of object oriented
programming. Although I have been aware of the basic concepts of
OOP for about 20 years, the opportunity to use it never came up in my
workaday C programming. Now that I've been retired for several
years I decided it would be interesting to learn a new language and
maybe get some practical experience with OOP, just for the fun of it,
of course. Well, although I'm very definitely still in the early
learning phase, it has been fun. I'm reanimating numerous neurons
which were beginning to rot for lack of use. However, an
interesting problem has appeared. I have already acquired several
“real” books on using the Pi and Python as well as several
others in .pdf form and many more are available. In addition
there seems to be many web sites dedicated to it, one by the Raspberry
Pi Foundation (a charitable organization) itself, but I've found
that frequently none of them answer the whole of whatever question I
have at the moment. This has lead me to, at times, wander the
halls of what I've come to call “hypertext hell” seemingly
endlessly to find the answers I seek.
This experience got me to
thinking (a dangerous thing :-). I remember back in early 1967
(46 years ago !!) when I decided I should learn FORTRAN. Sitting
with Pat in front of one of the ASR 35's in Scaife Hall the previous
fall, I had learned the rudiments of Algol on the G-20's. When I
went to learn FORTRAN I found that the G-20's just had a FORTRAN II
compiler and a buggy one at that. After several failed attempts
to get even a simple program to compile, I gave up. Although the
IBM 360/ 67 was being installed and tested at that time, its schedule
was erratic. This left the IBM 7040. Now the CIT (CMU)
Computation Center was discouraging use of the 7040 as it was mostly
used for funded research which would always have priority and thus turn
time for other jobs would be long. At least that was the
story. Sometimes this was true, but I befriended a number of the
computer operators (this was a year before I became one), particularly
the night shift crew, and frequently the 7040 would run out its job
queue early in the AM leaving several uninterrupted hours where the
machine was just sitting idle. As I came to know the
operators they would just let me use the machine directly without
having to submit jobs through the I/O desk and I could spend several
hours in the middle of the night in front of the machine running and
debugging my own jobs. As I related elsewhere, I missed seeing
the buggy races both days during the 1967 spring carnival as I had been
up the previous nights playing with the 7040. When I went to bed
both mornings at about 6 AM and set my alarm for several hours later, I
slept right through it both days.
Well, the experience with
the Pi and Python in “hypertext hell” got me to thinking of
the documentation I had needed to learn FORTRAN. It took
some mining around here but I found the four documents I had
used. Two, “7040 Reference Guide” and “Notes
for 7040 FORTRAN Users” were published by the CIT Computation
Center. The third was the IBM document C-28-6329-3 “IBM
7040/7044 Operating System (16/32K) FORTRAN IV Language”.
The last, and by no means the least, was the 1965 issue of Daniel D.
McCracken's “A Guide to FORTRAN IV Programming”. His
book on Algol programming had already been of great help with that
language. This was all I used in the way of documentation in
order to learn FORTRAN IV. Stacked, these four documents make a
pile less than 3/4ths of an inch thick. The “Raspberry Pi
for Dummies” book I have purchased (no comments :-) alone is an
inch thick and that's only one of the books I have acquired for the Pi
and Python. The just released 5th edition of “Learning
Python” by Mark Lutz I just acquired is, at over 1500 pages,
about 2.75 inches thick. It probably has all the information I
will require somewhere inside, if, at my “advanced age”, I
live long enough to read it all :-)
It seems we have gone from
using room-sized computers requiring minimal documentation to employ
effectively to using tiny computers which seem to require a room-sized
library of documentation. I decided to illustrate this with
a photograph. As I have also previously related elsewhere, there
was that day in early summer 1971 when I had the joy of being the one
to disassemble the UNIVAC 1108 processor box into small enough pieces
to be able to fit into the Scaife Hall elevator. As I was pulling
up floor boards to pull out cables for the 1108, I found two tapes in a
box under the false floor. These two tapes were labeled S.SLB1
and S.SLB2 and had been the last “on the machine” system
tapes for the 7040. Only a short length of the tape on each reel
was actually used but as it was used constantly it would wear
out. When this happened, the worn section would be cut off and a
new reflective load point put on the remaining tape. Then a new
image would be copied to it from a master tape. Both these tapes
have dates when they were made this way in the first half of
1967. The 7040 was retired later that year and for some unknown
reason the tapes had been left “sleeping” under the false
floor for the several years since. Thinking them historic even
back then, I saved them. The attached photo shows these two tapes
and the four documents I used to learn FORTRAN IV on the 7040.
Right in the middle of the photo is a blank punch card and sitting on
top of the punch card is a Raspberry Pi :-)
But that's not the end of
the story. In looking at all this I realized it had been at least
three decades since I had written a single line of FORTRAN.
Thinking it would be fun, at least briefly, to do it again, I took a
break from Python and sort of went back to my roots. As the whole
GNU gcc package is available for the Pi, I downloaded the GNU FORTRAN
(“gfortran”) part of it. This compiler is actually
quite flexible in its support for the various FORTRAN standards which
have come along over the years. It even supports free form
FORTRAN input (Free form FORTRAN input, sacrilege say I! :-), but I was
going to do it the good old fashioned way starting in column 7 and all
in caps. I therefore wrote several small FORTRAN routines to run
on the Pi. It took a little while to regain my FORTRAN legs but
thanks once again to McCracken they came back. I was forcing the
compiler to only accept the original fixed format input which lead to
one funny instance. I was getting a compile error on a
FORMAT statement and I couldn't understand why, it looked good to
me. All of a sudden it came to me, leaving me ROTFL.
The FORMAT statement in question was for a header text line and thus
was quite long. It turns out I had exceeded my allotment of 72
columns on my imaginary “card image” so the compiler was
not seeing the end of the FORMAT statement :-).
Now, unfortunately (or more
likely, fortunately :-), none of the FORTRAN I wrote either at CIT/CMU
or later has survived in my files. I think I recall doing at
least a couple of the exercises from McCracken's book on the 7040 but
also wrote a number of things on my own. The first few years of
my working life (and the last 17) I was writing control system software
which more or less had to predict the future and then bet on it.
If you seriously lost the bet you would end up with a 100 tons or more
of wreckage piled up not to mention a few unhappy people wondering why
(been there, done that, many times :-). I used to refer to the
process as applied high school physics. When I first inherited
this task, this prediction was done more or less by guess and by golly
with minimal input. I decided that to make my life easier I
needed to at least try to improve this situation. Some of this
involved standing out in the hot sun with a stop watch and clipboard
and recording data manually. I then needed to somehow analyze
this data.
At this point in the early
70's a physics PhD friend suggested a book, “Data Reduction and
Error Analysis for the Physical Sciences” by Philip R.
Bevington. The first edition of this book, published in 1969 had
two neat things about it. First and foremost, the various chapter
subjects were illustrated by tested and working FORTRAN subroutines
which could be easily lifted and used. Secondly, in the
acknowledgments at the beginning of the book, our own crazy CIT physics
professor and Renaissance man, Hugh D. Young, was given especial
mention for his aid with the book. I got a copy and proceeded to
write FORTRAN data analysis programs using selected routines out of
this book (running them on a 360, either my employer's or a customers
if I was out on a job site. There were no viable FORTRAN
compilers on my target systems at the time. My control system
programming back then was all in assembler.). With this I was, at
least to a point, able to improve the accuracy of some of the
predictions (There are still, to this day, too many variables to this
problem, both unknown and economically unmeasurable). Just FYI,
there have been two later editions of this book, the second apparently
had Pascal routines and the third, from 2003, has C++ routines.
Although the third edition of the book is expensive, you can download
both the C++ routines and newer versions of the FORTRAN routines for
free from the book's web site at:
http://highered.mcgraw-hill.com/sites/0072472278/ . As I still
have the original edition of this book I have taken a couple of the
original routines from it and once again written little data analysis
programs using them, running them on the Pi just for the joy of
it. It's been an amusing experience.
Now, if I wanted to go
further, the next step would be to emulate an IBM 7040 on the Pi.
People are already running a 360/370/380/390 series emulator on the Pi
(Hercules, see: http://mainframed767.tumblr.com/post/41201454530/a-mainframe-on-your-raspberry-pi )
so I assume it would be
possible. In fact, it turns out that one of my private rail car
friends has a web site on 7090/7094 systems which includes links to a
number of such things some of which which he has actively participated
in developing and supporting. (See: http://www.cozx.com/~dpitts/ibm7090.html
). Included are a 709/7090 simulator and IBSYS sources. I
suspect these could be hacked to do a 7040. However, there is a
thin line between success and excess and if I haven't already crossed
it with my FORTRAN efforts above, I certainly would if I undertook this
effort. I think it's time to get back to learning Python... |
earthlink.net>
I received these emails and followup photos of the 7040:
