TUHS August 2017

tuhs@tuhs.org

41 participants
28 discussions

by jnc＠mercury.lcs.mit.edu

> 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 RUNOFF? Noel

7 years, 4 months

Re: [TUHS] arithmetic IF (was origin of string.h and ctype.h)

by Paul McJones

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 .

7 years, 4 months

CSTR 122 on CHEM?

by arnold＠skeeve.com

Does anyone have this, even just in PostScript? Thanks, Arnold P.S. Chem itself is at http://www.netlib.org/typesetting/chem.

7 years, 4 months

[tuhs] new paper on Unix pipes

by Nelson H. F. Beebe

This new paper was published today, and it is open access, so everyone should have access: Diomidis Spinellis and Marios Fragkoulis Extending Unix Pipelines to DAGs IEEE Transactions on Computers 66(9) 1547--1561 September 2017 http://dx.doi.org/10.1109/TC.2017.2695447 ------------------------------------------------------------------------------- - 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/ - -------------------------------------------------------------------------------

7 years, 4 months

Re: [TUHS] arithmetic IF (was origin of string.h and ctype.h)

by Doug McIlroy

> [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. doug

7 years, 4 months

Re: [TUHS] arithmetic IF (was origin of string.h and ctype.h)

by Paul Winalski

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.) > > Doug > >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 maybe neither? 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. -Paul W.

7 years, 4 months

Re: [TUHS] arithmetic IF (was origin of string.h and ctype.h)

by Doug McIlroy

> 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. doug

7 years, 4 months

Re: [TUHS] TUHS] origin of string.h and ctype.h

by Doug McIlroy

>> 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.) Doug

7 years, 4 months

Re: [TUHS] origin of string.h and ctype.h

by Paul McJones

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. http://www.bitsavers.org/pdf/ibm/704/704_FortranProgRefMan_Oct56.pdf (For more on the original FORTRAN compiler, see http://www.softwarepreservation.org/projects/FORTRAN/.)

7 years, 4 months

Re: [TUHS] origin of string.h and ctype.h

by Paul McJones

On Tue, 15 Aug 2017, Dave Horsfall <dave(a)horsfall.org> wrote: >> On Mon, 14 Aug 2017, Paul Winalski wrote: >> >> [ Ye olde 704 ] >> >>> TMP (transfer on plus) >> > That's rather an odd mnemonic… Actually, the 704 manual of operation gives the mnemonic as TPL: http://www.bitsavers.org/pdf/ibm/704/24-6661-2_704_Manual_1955.pdf

7 years, 4 months

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

2000

1999

1998

1997

1996

1995

1994

1993

1992

1991

1990

TUHS August 2017