[TUHS] ratfor vibe

[Clem Cole]

On Tue, Feb 1, 2022 at 10:53 AM Ralph Corderoy <ralph at inputplus.co.uk>
wrote:

> I agree the original Software Tools is a must read, but having done so,
> why would I suffer working through the hurdles put in place by Pascal
> compared to Ratfor?

I'll take a stab.  Again set Arnold's  Way-Back machine to the late '60 and
through the mid 1970s.  The Algol vs. FTN war was raging.   FTN had 'won'
the Science and Engineering communities and Algol was the Math/CS types
[I'm over simplifying].   In fact, when I was at CMU in the mid-70s; my
professors all said *FTN was dead*  ( mind you production quality FTN code
has paid my salary in the HPC world my entire career ).  At CMU, the
compromise is all engineers were required to take an intro to computing
using in FTN/WATFIV course and then all other 200 level or greater CS
course after that were usualy based using an Algol/ or later Pascal.

The point being any reasonable computer system being brought to market
by a *credible
systems vendor* had at least an implementation of FTN4 that could pass the
ANSI test suite and many started to have one that support F77 [although
thank you DEC VMS FTN != F77].   But ... because of the push from the
teaching/CS side in most places, Pascal started to show up as a standard
offering [C did not - yet - have that backing].   I suspect if you check my
generation and for the next 10-20 years after, you will see Pascal was the
first language you saw in college.

So by the late 70s/early 80s, [except for MIT where LISP/Scheme reigned]
Pascal had become the primary teaching language for the CS communities at
most schools.   C was considered a tad 'dirty' [not as bad as assembler --
but close].  It might have been used in an OS or Compiler course.  In fact
in the grad Graphics course I took, which was taught by Xerox folks, I had
to get a special exception to use C.

But the fact is, at that time, if you read the literature, you would
believe that Pascal was going to be the future. Hence the concept of doing
the SWT in Pascal made sense >>in theory<<. Another important fact was that
while the P4 system made moving Pascal easier than many other languages, as
Rob pointed out, the Pascal I/O was so screwy and frankly not well bound to
the host OS, that every new implementation messed with it in some manner
[see Brian's wonderful tome for more details].   Similarly, the lack of
standardized way to do separate compilation for support libs (which had
been a prime idea in FTN and allowed a rich market for libraries), really
had a huge effect.  Again it was solved many times with each compiler
implementation, but each scheme tended to be a little different.

Fortran, of course, had been around long enough and had an ANSI standard
(and a test suite for it) at least made portable FTN possible.

So the theory was good -- Pascal was a 'better' language in theory and
everyone was coming out of school knowing it.

Again, reality ...  since UNIX came with C and was 'open source' in the
sense that everyone that had it, had the AT&T source code.  One of the
first things that happened was C was retargeted to a number of processors
-- often not by either the manufacturer or by the system vendor.
Interestingly, this was about 50/50 between Academics/Research and
Industry.   So while all the world's ISA were not a PDP-11, the fun part is
the code *could be made reasonably* portable - in fact *in practice*
[partly because C had a pre-processor which Pascal did not and of course is
what ratfor is] have one source base that could compile for different
targets.

The problem (as you note) these issues are >>obvious<< in hindsight, but
during that time -- it was not.  It certainly seems like Pascal had a lot
of momentum. They were a lot compilers for a lot of systems.   Look, it was
the language Apple used for the Lisa and Mac.  Things like UCSD Pascal was
being made by the press as 'the answer for 8 bit processors' [note MSFT had
a FTN for the 8080 on CPM in those days].   Turbo Pascal was, in fact,
an excellent compiler.  But C was starting to come on strong.

FWIW:  In the end, I personally believe that C 'won' because the practical
side made it cheaper to use (economics always beat architecture).  The
cynical part of me thinks that a big reason why C++ caught on is because a
lot of the pro-Pascal community got to sing the praises of OOP with C++ and
they could change sides without claiming C beat Pascal.  Hey, Microsoft
made a pretty good C for DOS and finally going C++ probably helped.  It
sold more than the FORTRAN and my guess is that people using FORTRAN at
that point were scientists and needed the address space that 8086 did not
have. The 386 with a linear address for using things like the PharLap tools
made it possible and frankly the Intel 8087 started to make that processor
a better target for science.

In the end, Pascal never had a code base like the FTN Scientific code base
or todays C and C++ code base.   FWIW: I can think of few production Pascal
codes from those days that are still being used [other than the Front-End
of the DEC/Intel FORTRAN compiler - which was moved from BLISS to Pascal
for all the same 'C is dirty' issues BTW].
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20220201/b642f48d/attachment.htm>