Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.compilers > #2501 > unrolled thread

Languages from the 1950s

Back to article view | Back to comp.compilers

Contents

  Languages from the 1950s "Derek M. Jones" <derek@_NOSPAM_knosof.co.uk> - 2020-03-30 15:16 +0100
    Re: Languages from the 1950s anton@mips.complang.tuwien.ac.at (Anton Ertl) - 2020-03-31 17:08 +0000
      Re: Languages from the 1950s "Derek M. Jones" <derek@_NOSPAM_knosof.co.uk> - 2020-03-31 19:27 +0100
    Re: Languages from the 1950s gah4@u.washington.edu - 2020-03-31 16:09 -0700
      Re: Languages from the 1950s "Robin Vowels" <robin51@dodo.com.au> - 2020-04-02 13:05 +1100
    Re: Languages from the 1950s "Robin Vowels" <robin51@dodo.com.au> - 2020-04-01 21:31 +1100
      Re: Languages from the 1950s "Derek M. Jones" <derek@_NOSPAM_knosof.co.uk> - 2020-04-01 17:35 +0100
    Re: Languages from the 1950s Philipp Klaus Krause <pkk@spth.de> - 2020-04-01 17:49 +0200
    Re: Languages from the 1950s rst@panix.com (Robert Thau) - 2020-05-10 00:46 +0000
      Re: Languages from the 1950s Martin Ward <martin@gkc.org.uk> - 2020-05-13 10:51 +0100
    Re: Languages from the 1950s "Robin Vowels" <robin51@dodo.com.au> - 2020-09-03 21:02 +1000

#2501 — Languages from the 1950s

All,

I looking for manuals for languages from the 1950s,
the earlier the better.

There were lots of languages around (we just don't know much
about them today):
http://shape-of-code.coding-guidelines.com/2017/05/21/evidence-for-28-possible-compilers-in-1957/

--
Derek M. Jones
blog:shape-of-code.coding-guidelines.com
[I presume you've looked through bitsavers. -John]

[toc] | [next] | [standalone]

#2502

"Derek M. Jones" <derek@_NOSPAM_knosof.co.uk> writes:
>All,
>
>I looking for manuals for languages from the 1950s,
>the earlier the better.

Not a manual, but "The Early Development of Programming Languages" by
Donald Knuth and Luis Trabb Pardo is a longish paper that provides a
nice overview, as well as lots of literature references.  It is
reprinted in Knuth's "Selected Papers on Computer Languages".

- anton
--
M. Anton Ertl
anton@mips.complang.tuwien.ac.at
http://www.complang.tuwien.ac.at/anton/

[Good thought -- it's 90 pages of Knuthy goodness.  You can find a
scan of a version released as a Stanford tech report at
https://archive.org/details/DTIC_ADA032123 -John]

[toc] | [prev] | [next] | [standalone]

#2503

Anton,

> Not a manual, but "The Early Development of Programming Languages" by
> Donald Knuth and Luis Trabb Pardo is a longish paper that provides a
> nice overview, as well as lots of literature references.  It is

I am after details.

The paper: "Early LISP History (1956 - 1959)"
is fully of interesting material.

There are Fortran manuals from 1957 and onwards.

As an aside: the ACM has made its papers freely available for three months:
dl.acm.org/

--
Derek M. Jones
blog:shape-of-code.coding-guidelines.com
[The Knuth paper has a lot of details.  Well worth the download.  That
Lisp paper is here https://dl.acm.org/doi/10.1145/800055.802047 -John]

[toc] | [prev] | [next] | [standalone]

#2504

On Tuesday, March 31, 2020 at 9:04:52 AM UTC-7, Derek M. Jones wrote:

> I looking for manuals for languages from the 1950s,
> the earlier the better.

I first started looking for such in the 1970's, and had some
books from the library used book sale.  The only one I remember
now is JOVIAL, which I remember never knowing any computer that
ran it, but still had to book for it.  I might also have
had a book for JOSS.

It seems to me that there were a lot of machine specific
low-level languages, about at the assembly level, before the
machines were big enough to run compilers.

There is FLOW-MATIC, which Grace Hopper worked on before COBOL:

https://en.wikipedia.org/wiki/FLOW-MATIC

It seems to me that COBOL goes to about 1960, so doesn't qualify
as the 1950's.  AIMACO and COMTRAN were also on the pathway to COBOL.

IBM RPG also traces back to the 1950s, so that should apply.
It seems that FARGO is related to RPG.

As well as I know, Fortran from about 1956 is credited with
the idea of symbolic names more than one character long.
(Seems so obvious now.)  There is FORTRANSIT for the IBM 650,
which doesn't seem to even have a Wikipedia page.

There is FOCAL and SNOBOL from the 1960's.
COMIT is a predecessor to SNOBOL from the 1950's.

> [I presume you've looked through bitsavers. -John]

It is hard to look through bitsavers without knowing the name.
If you find some old machine, though, then you can see which languages
people ran on it.

I suspect that the languages you might actually want to know
about came in the early 1960's.

[toc] | [prev] | [next] | [standalone]

#2508

From: <gah4@u.washington.edu>
Sent: Wednesday, April 01, 2020 10:09 AM

> It seems to me that there were a lot of machine specific
> low-level languages, about at the assembly level, before the
> machines were big enough to run compilers.

Even very early machines were capable of running compilers.

The DEUCE (1955), which had a high-speed memory of 384 words
ran ALGOL, ALPHACODE, and GEORGE.

For GEORGE there was both a compiler and an interpreter.
ALPHACODE was a compiler.
OTMH, ALGOL also was a compiler.

DEUCE was the production verion of the pilot ACE, so it would have
been possible to run a compiler on it, though whether any was
I do not know, though both pilot ACE and  DEUCE were operating
concurrently.

[toc] | [prev] | [next] | [standalone]

#2505

A programming manual c. 1958 for GEORGE:

http://members.iinet.net.au/~dgreen/deuce/GEORGEProgrammingManual.pdf

The first version was working in early 1957, and details were presented:

An addressless coding scheme based on mathematical notation. Proceedings of the First Australian
Conference on Computing and Data Processing, Salisbury, South Australia: Weapons Research
Establishment, June 1957.

[toc] | [prev] | [next] | [standalone]

#2507

Robin,

> A programming manual c. 1958 for GEORGE:
>
> http://members.iinet.net.au/~dgreen/deuce/GEORGEProgrammingManual.pdf

Thanks for this.  The names of languages are easy to find, but manuals
describing them are hard to find (added you link to the Deuce Wikipedia page).

One of the uses of language manuals is in working out when language features
first started being used.

For instance, Lisp seems to be the first to use garbage collection.  But in the
world of tiny memory there might be an earlier language that garbage collected.

--
Derek M. Jones
blog:shape-of-code.coding-guidelines.com
[Remember that in that era even stack allocation of local variables wasn't
well understood.  I gather it came as a surprise to many that
Algol60's recursion and memory allocation were easy to implement.  I
would expect any dynamic allocation to have been extremely ad-hoc
-John]

[toc] | [prev] | [next] | [standalone]

#2506

Am 30.03.20 um 16:16 schrieb Derek M. Jones:
> All,
>
> I looking for manuals for languages from the 1950s,
> the earlier the better.
>
> There were lots of languages around (we just don't know much
> about them today):
> http://shape-of-code.coding-guidelines.com/2017/05/21/evidence-for-28-possible-compilers-in-1957/

Slightly outside your time range: Plankalkül, a high-level language
developed 1942-1946, first implemented in 1975.

However, Konrad Zuse, "Über den Allgemeinen Plankalkül als Mittel zur
Formulierung schematisch-kombinativer Aufgaben", Archiv der Mathematik
volume 1, pages 441-449 (1948) is not in ACM, and Springer didn't make
their stuff freely available yet, but there is Sci-Hub, and there is
later documentation also.

Philipp
[The Knuth paper has 7 pages on Plankalkül, including a sample program.
Here's a cleaner copy at bitsavers:
http://bitsavers.org/pdf/stanford/cs_techReports/STAN-CS-76-562_EarlyDevelPgmgLang_Aug76.pdf
-John]

[toc] | [prev] | [next] | [standalone]

#2516

In article <20-03-030@comp.compilers>,
Derek M. Jones <derek@_NOSPAM_knosof.co.uk> wrote:
>All,
>
>I looking for manuals for languages from the 1950s,
>the earlier the better.
>
>There were lots of languages around (we just don't know much
>about them today):
>http://shape-of-code.coding-guidelines.com/2017/05/21/evidence-for-28-possible-compilers-in-1957/

It's worth noting that the whole nomenclature of "assembler",
"compiler" and "interpreter" was not really established at the time --
the Laning-Zierler algebraic language for the Whirlwind (which is at
least one of the Whirlwind entries, and possibly all three) was a
compiler according to modern definitions of the word -- it generated
machine code from an input language that was mostly algebraic
expressions -- but its own documentation, here:

  http://bitsavers.trailing-edge.com/pdf/mit/whirlwind/E-series/E-364_A_Program_For_Translation_of_Mathematical_Equations_For_Whirlwind_I_Jan54.pdf

calls it "interpretive".  There are other systems on the list which
were implemented as what we'd call interpreters nowadays.  Mauchly's
Short Code for the Univac may be the first; it was running by 1950.
I believe Backus's Speedcoding for the 701 is also in this category.

With that in mind, I can identify quite a few entries in that list as
being what we'd call assemblers nowadays, including at least SOAP I and
II for the IBM 650, the X-1 assembler for the Univac (I and II), SAP for
the 704 (also available for the 709; see below), and at least a few of
the several "AUTOCODER"s.

There are a few other things on the list that are at least arguably
double-counting -- the IBM 709 was a mostly upward-compatible extension
of the 704 with better I/O hardware, and the FORTRAN compilers for
the two machines shared just about all of their code outside of the I/O
library.

(As a sidelight, the sheer number of FORTRAN compilers is interesting,
particularly as this happened without any formal standardization effort.
This also suggests there may be a little back-dating going on in some
of these cases.  The first of these to be released was 704 FORTRAN, and
it wasn't released until early 1957 itself; all the others must have
come later, and a compiler in those days was not a small project.)

Robert Thau
rst@ai.mit.edu
[SOAP II was definitely an assembler.  I have the manual.  It was an
"optimizing" assembler in that it tried to place instructions in
locations on the 650's drum to minimize the rotational delay. -John]

[toc] | [prev] | [next] | [standalone]

#2518

On 10/05/2020 01:46, John wrote:
> It was an "optimizing" assembler in that it tried to place
> instructions in locations on the 650's drum to minimize the
> rotational delay. -John

When I read this I thought "how quaint!". But then I remembered
that with modern heavily pipelined CPU's, compilers also need
to place instructions in the right order so that each instruction
in the sequence is executed just as the hardware components
that it needs become available, to minimise the pipeline delay.

Plus ça change, plus c'est la même chose.

--
			Martin

Dr Martin Ward | Email: martin@gkc.org.uk | http://www.gkc.org.uk
G.K.Chesterton site: http://www.gkc.org.uk/gkc | Erdos number: 4
[It's remarkable how little modern software technology wasn't already
done somewhere in the 1950s or 1960s.  -John]

[toc] | [prev] | [next] | [standalone]

#2583

From: "Derek M. Jones" <derek@_NOSPAM_knosof.co.uk>
Sent: Tuesday, March 31, 2020 12:16 AM
> I looking for manuals for languages from the 1950s,
> the earlier the better.

Manchester University holds copies of ALPHACODE for the
DEUCE.

D14 holds DEUCE ALPHACODE manuals.
D24 holds DEUCE PROGRAM NEWS, January 1958,
                   which is the Mark 2 version of ALPHACODE.
D34 holds the supplement to DEUCE Program News No. 20
                   (Alphacode Mark 2).

[toc] | [prev] | [standalone]

Back to top | Article view | comp.compilers

csiph-web