> From: John Labovitz
> I found the earliest succession of roff predecessors went something like this:
> TJ-2 -> RUNOFF (capitals) -> runoff (lowercase) -> rf -> roff
Did you manage to find out from Jerry if he knew of/anything about TJ2 when he did
On Aug 17, 2017, arnold(a)skeeve.com wrote:
> I remember reading an article somewhere on the history of the first
> FORTRAN compiler. The guys doing it wanted it to succeed, and they
> were fighting the mentality that high level languages could not possibly
> be as efficient as hand-coded assembly, so they put a lot of work into
> the optimization of the generated code.
> It worked so well that the results that came out of the compiler
> sometimes suprised the compiler writers! They then would have to
> dive into the compiler sources to figure out how it was done.
> I don't remember where I read this article. If the story rings a
> bell with anyone, let me know.
In his paper "The history of FORTRAN I, II and III” presented at the First ACM SIGPLAN conference on History of Programming Languages (1978), John Backus said:
> It was an exciting period; when later on we began to get fragments of compiled programs out of the system, we were often astonished at the surprising transformations in the indexing operations and in the arrangement of the computation which the compiler made, changes which made the object program efficient but which we would not have thought to make as programmers ourselves (even though, of course, Nelson or Ziller could figure out how the indexing worked, Sheridan could explain how an expresssion had been optimized beyond recognition, and Goldberg or Sayre could tell us how section 5 had generated additional indexing operations). Transfers of control appeared which corresponded to no source statement, expressions were radically rearranged, and the same DO statement might produce no instructions in the object program in one context, and in another it would produce many instructions in different places in the program.
The paper is available here, courtesy of ACM: http://www.softwarepreservation.org/projects/FORTRAN/index.html .
This new paper was published today, and it is open access, so everyone should
Diomidis Spinellis and Marios Fragkoulis
Extending Unix Pipelines to DAGs
IEEE Transactions on Computers 66(9) 1547--1561 September 2017
- Nelson H. F. Beebe Tel: +1 801 581 5254 -
- University of Utah FAX: +1 801 581 4148 -
- Department of Mathematics, 110 LCB Internet e-mail: beebe(a)math.utah.edu -
- 155 S 1400 E RM 233 beebe(a)acm.org beebe(a)computer.org -
- Salt Lake City, UT 84112-0090, USA URL: http://www.math.utah.edu/~beebe/ -
> [Fortran's optimization] worked so well that the results that came out of the compiler
> sometimes suprised the compiler writers!
Except when it didn't. They gave particular attention to nested
loops with subscripted variables, exemplified by linear-algebra
computations. But their algorithms behaved quite wildly on
nonstandard loops. Vic Vyssotsky cooked up a nest of loops
surrounding a single awful statement that filled up the
maximum 10 continuation lines with triple subscripts in all
permutations of several variables. That statement compiled
into thousands of instructions, far more than a naively
written compiler would have produced.
On 8/16/17, Doug McIlroy <doug(a)cs.dartmouth.edu> wrote:
>>> the 709 added CAS
>> It was my understanding that the 704 had this instruction too
> Yes. It's in the manual.
> (I searched in vain for an online manual. A quick trip to the
> attic turned up the real thing in less time.)
>From what I've been able to determine, FORTRAN came out shortly after
the IBM 704. Undoubtedly both were under development at the same
time. So the question is, was arithmetic IF put in FORTRAN to take
advantage of the CAS instruction, or was CAS added to the IBM 704
instruction set to provide hardware support for arithmetic IF? Or
According to the Wikipedia article on FORTRAN, CAS was usually not the
most efficient way to implement arithmetic IF anyway. CAS takes up
four words of memory and takes three cycles to execute, whereas you
can do it in two words and two cycles with the transfer instructions.
> According to the Wikipedia article on FORTRAN, CAS was usually not the
> most efficient way to implement arithmetic IF anyway. CAS takes up
> four words of memory and takes three cycles to execute, whereas you
> can do it in two words and two cycles with the transfer instructions.
Though the article's conclusion was right, its numbers were wrong.
As a correct discussion of possible implementations of arithmetic-IF
would be long and essentially off topic, I have chopped most of it
out of the article.
>> the 709 added CAS
> It was my understanding that the 704 had this instruction too
Yes. It's in the manual.
(I searched in vain for an online manual. A quick trip to the
attic turned up the real thing in less time.)
On Sun, 13 Aug 2017, Dave Horsfall wrote:
> On Sat, 12 Aug 2017, Steve Johnson wrote:
>> A little Googling shows that the IF I mentioned was called the
>> "arithmetic IF".
> Ah yes. It was in FORTRAN II, as I recall.
It turns out the original FORTRAN (manual published in October 1956; code first shipped around April 1957) included the arithmetic IF as well as the assigned and computed GOTO statements — see chapter 4 of this manual:
J.W. Backus, R.J. Beeber, S. Best, R. Goldberg, H.L. Herrick, R.A. Hughes, L.B. Mitchell, R.A. Nelson, R. Nutt, D. Sayre, P.B. Sheridan, H. Stern, I. Ziller. The FORTRAN Automatic Coding System for the IBM 704 EDPM : Programmer's Reference Manual. Applied Science Division and Programming Research Department, International Business Machines Corporation, October 15, 1956, 51 pages.
(For more on the original FORTRAN compiler, see http://www.softwarepreservation.org/projects/FORTRAN/.)