DOCSLIB.ORG

Programming Languages-The First 25 Years

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text

Load more

IEEE TRANSACTIONS ON COMPUTERS, VOL. C-25, NO. 12, DECEMBER 1976 1207 Programming Languages-The First 25 Years PETER WEGNER Abstract-The programming language field is certainly one of 1950-1960 Discovery and Description the most important subfields of computer science. It is rich in concepts, theories, and practical developments. The present paper A remarkably large number of the basic concepts of attempts to trace the 25 year development of programming lan- programming languages had been discovered and imple- guages by means of a sequence of 30 milestones (languages and mented by 1960. This period includes the development of concepts) listed in more or less historical order. The first 13 mile- stones (Ml-M13) are largely concerned with specific programming symbolic assembly languages, macro-assembly languages, languages of the 1950's and 1960's such as Fortran, Algol 60, Cobol, Fortran, Algol 60, Cobol, IPL V, Lisp, and Comit [72]. It Lisp, and Snobol 4. The next ten milestones (M14-M23) relate to includes the discovery of many of the basic implementation concepts and theories in the programming language field such as techniques such as symbol table construction and look-up formal language theory, language definition, program verification, techniques for assemblers and macro-assemblers, the stack semantics and abstraction. The remaining milestones (M24-M30) relate to the software engineering methodology of the 1970's and algorithm for evaluating arithmetic expressions, the acti- include a discussion of structured programming and the life cycle vation record stack with display technique for keeping concept. This discussion of programming language development track of accessible identifiers during execution of block is far from complete and there are both practical developments structure languages, and marking algorithms for garbage such as special purpose languages and theoretical topics such as collection in languages such as IPL V and Lisp. the lambda calculus which are not adequately covered. However, it is hoped that the discussion covers the principal concepts and This period was one of discovery and description of languages in a reasonably nontrivial way and that it captures the programming languages and implementation techniques. sense of excitement and the enormous variety of activity that was Programming languages were regarded solely as tools for characteristic of the programming language field during its first facilitating the specification of programs rather than as 25 years. interesting objects of study in their own right. The devel- Index Terms-Abstraction, assemblers, Algol, axioms, Cobol, opment of models, abstractions, and theories concerning compilers, Fortran, Lisp, modularity, programming languages, programming languages was largely a phenomenon of the semantics, structures programming, syntax, verification. 1960's. I. THREE PHASES OF PROGRAMMING LANGUAGE 1961-1969 Elaboration and Analysis DEVELOPMENT The 1960's were a period of elaboration of programming T HE 25 year development of programming lan- languages developed in the -1950's and of analysis for the guages may be characterized by three phases corre- purpose of constructing models and theories of program- sponding roughly to the 1950's, 1960's, and 1970's. The ming languages. 1950's were concerned primarily with the discovery and The languages developed in the 1960's include Jovial, description of programming language concepts. The 1960's PL/I, Simula 67, Algol 68, and Snobol 4. These languages were concerned primarily with the elaboration and anal- are, each in a different way, elaborations of languages de- ysis of concepts developed in the 1950's. The 1970's were veloped in the 1950's. For example, EL/I is an attempt to concerned with the development of an effective software combine the "good" features of Fortran, Algol, Cobol, and technology. As pointed out in [96], the 1950's emphasized Lisp into a single language. Algol 68 is an attempt to gen- the empirical approach to the study of programming eralize, as systematically and clearly as possible, the lan- language concepts, the 1960's emphasized a mathematical guage features of Algol 60. Both the attempt to achieve approach in its attempts to develop theories and general- greater richness by synthesis of existing features and the izations of concepts developed in the 1950's, and the 1970's attempt to achieve greater richness by generalization have emphasized an engineering approach in its attempt to led to excessively elaborate languages. We have learned harness concepts and theories for the development of that in order to achieve flexibility and power of expression software technology. in programming languages we must pay the price of greater complexity. In the 1970's there is a tendency to retrench Manuscript received September 3, 1976; revised August 23, 1976. This towards simpler languages like Pascal, even at the price of work was supported in part by the AFOST, the ARO, and the ONR under restricting flexibility and power of expression. Contract N00014-76-C-0160. The author is with the Division of Applied Mathematics, Brown Uni- Theoretical work in the 1960's includes many of the versity, Providence, RI 02912. basic results of formal languages and automata theory with 1208 IEEE TRANSACTIONS ON COMPUTERS, DECEMBER 1976 applications to parsing and compiling [1]. It includes the specific programming languages, and the development of development of theories of operational and mathematical implementation techniques, concepts and theories. semantics, of language definition techniques, and of several The four most important milestones are probably the frameworks for modeling the compilation and execution following ones. process [26]. It includes the development of the basic ideas Fortran, which provided an existence proof for higher of program correctness and program verification [54]. level languages, and is still one of the most widely used Although much of the theoretical work started in the programming languages. 1960's continued into the 1970's, the emphasis on theo- Algol 60, whose clean design and specification served as retical research as an end in itself is essentially a phe- an inspiration for the development of a discipline of pro- nomenon of the 1960's. In the 1970's theoretical research gramming languages. in areas such as program verification is increasingly mo- Cobol, which pioneered the development of data de- tivated by practical technological considerations rather scription facilities, was adopted as a required language on than by the "pure research" objective of advancing our department of defense computers and has become the understanding independently of any practical payoff. most widely used language of the 1970's. In the programming language field the pure research of Lisp, whose unique blend of simplicity and power have the 1960's tended to emphasize the study of abstract caused it to become both the most widely used language structures such as the lambda calculus or complex struc- in artificial intelligence and the starting point for the de- tures such as Algol 68. In the 1970's this emphasis on ab- velopment of a mathematical theory of computation. straction and elaboration is gradually being replaced by We shall consider about 30 milestones, and use this an emphasis on methodologies aimed at improving the section as a vehicle for presenting a brief history of the technology of programming. programming language field. The milestones can be split into three groups. Milestones M1-M13 are concerned 1970-? Technology largely with specific programming languages developed During the 1970's emphasis shifted away from "pure during the 1950's and 1960's. Milestones M14-M23 con- research" towards practical management of the environ- sider certain conceptual and theoretical programming ment, not only in computer science but also in other sci- language notions. Milestones M24-M30 are concerned entific areas. Decreasing hardware costs and increasingly with programming languages and methodology of the complex software projects created a "complexity barrier" 1970's. in software Ml -The ED VAC report, 1944 [81]: This report, writ- development which caused the management ten Von Neumann of software-hardware complexity to become the primary by in September 1944, contains the first practical problem in computer science. Research was di- description of the stored program computers, subsequently rected away from the development of powerful new pro- called Von Neumann machines. It develops a (one address) gramming languages and general theories of programming machine language for such computers and some examples language structure towards the development of tools and of programs in this machine language. methodologies for controlling the complexity, cost, and M2-Book by Wilkes, Wheeler, and Gill, 1951 [83]: This reliability of large programs. is the first book on both application software and system Research emphasized methodologies such as structured software. It discusses subroutines and subroutine linkage, programming, module design and specification, and pro- and develops subroutines for a number of applications. It gram verification [41]. Attempts to design verifiable lan- contains a set of "initial orders" which act like a sophisti- guages which support structured programming and mod- cated loader, performing decimal to binary conversion for ularity are currently being made. Pascal, Clu, Alphard, operation codes and addresses, and having relative ad- Modula, and Euclid are examples
Recommended publications
  • Latest Results from the Procedure Calling Test, Ackermann's Function

    Latest Results from the Procedure Calling Test, Ackermann's Function

    Latest results from the procedure calling test, Ackermann’s function B A WICHMANN National Physical Laboratory, Teddington, Middlesex Division of Information Technology and Computing March 1982 Abstract Ackermann’s function has been used to measure the procedure calling over- head in languages which support recursion. Two papers have been written on this which are reproduced1 in this report. Results from further measurements are in- cluded in this report together with comments on the data obtained and codings of the test in Ada and Basic. 1 INTRODUCTION In spite of the two publications on the use of Ackermann’s Function [1, 2] as a mea- sure of the procedure-calling efficiency of programming languages, there is still some interest in the topic. It is an easy test to perform and the large number of results ob- tained means that an implementation can be compared with many other systems. The purpose of this report is to provide a listing of all the results obtained to date and to show their relationship. Few modern languages do not provide recursion and hence the test is appropriate for measuring the overheads of procedure calls in most cases. Ackermann’s function is a small recursive function listed on page 2 of [1] in Al- gol 60. Although of no particular interest in itself, the function does perform other operations common to much systems programming (testing for zero, incrementing and decrementing integers). The function has two parameters M and N, the test being for (3, N) with N in the range 1 to 6. Like all tests, the interpretation of the results is not without difficulty.
  • The History of the ALGOL Effort

    The History of the ALGOL Effort

    Technische Universiteit Eindhoven Department of Mathematics and Computer Science The History of the ALGOL Effort by HT de Beer supervisors: C. Hemerik L.M.M. Royakkers Eindhoven, August 2006 Abstract This report studies the importancy of the ALGOL effort for computer science. Therefore the history of the ALGOL effort is told, starting with the compu- tational context of the 1950s when the ALGOL effort was initiated. Second, the development from IAL to ALGOL 60 and the role the BNF played in this development are discussed. Third, the translation of ALGOL 60 and the establishment of the scientific field of translator writing are treated. Finally, the period of ALGOL 60 maintenance and the subsequent period of creating a successor to ALGOL 60 are described. ii Preface This history on the ALGOL effort was written as a Master thesis in Com- puter Science and Engineering (Technische Informatica) at the Eindhoven University of Technology, the Netherlands. iii Contents Abstract ii Preface iii Contents iv 0 Introduction 1 0.0 On the sources used ........................ 2 0.1 My own perspective ........................ 3 0.2 The ALGOL effort: a definition .................. 4 0.3 Notes ................................ 4 1 Creation 5 1.0 The start of the ALGOL effort ................... 5 1.1 The need for a universal algorithmic language ........... 7 1.1.0 The American field of computing ............. 7 1.1.1 The European field of computing ............. 9 1.1.2 The difference between Europe and the USA and the need for universalism ...................... 11 1.2 Why was IAL chosen over other algorithmic languages? ..... 11 1.2.0 IT ............................
  • Docworks PDF 600

    Docworks PDF 600

    P!l)_n.ted a.t .the Mathematic.al Cen.tJie, 413 K/f./.JMlaan, Am6.te.Jtdam. The Mathematic.al Cen.tJie , 6011.nded .the 11-.th 06 Feb'1.U1V1.IJ 1946, ,u., a non­ p!W 6U w:Ut.u.:tio n aJm.ing a.t .the pJWmo:Uo n o 6 pwr.e ma.the.ma:Ue!i and ill., appUc.ationJ.,. 1.t ,u., -6poY11.>01Led by .the Ne.the.Jtland6 Gove.Jtnmen.t .th!Wu.gh .the Ne..the.Jtland6 O!Lganiza:Uon 6DIL .the Advanc.e.men.t 06 PUILe Re-6e.a!Lc.h {Z.W.0.). MATHEMATICAL CENTRE TRACTS 134 PROCEEDINGS INTERNATIONAL CONFERENCE ON ALGOL 68 J.C. van VLIET (ed.) H. WUPPER (ed.) RECHENZENTRUM DER RUHR-UNIVERSITAT BOCHUM, BRD, MARCH 30-31, 1981 MATHEMATISCH CENTRUM AMSTERDAM 1981 1980 Mathematics·subjectclassification: 68-06,68B10,68B20 Co~uting Reviews: 4.22,1.52,4.34,4.12,5.23 l. INTRODUCTION "What can we do with ALGOL 68?" is the question raised by the chairman of the Standing Subcommittee on ALGOL 68 Support in the first contribution to this conference. The three main topics of the conference suggest three possible answers to this question: one can teach the language, implement it, and apply it. The papers collected in these proceedings deal with various aspects of teaching, implementation, and applications. They do not attempt to fully answer the question of what can be done, but they hopefully will provide some useful pieces of information, both to those who want to learn more about the,language, and to those who are actually involved in problems in the areas addressed.
  • Organization of Programming Languages

    Organization of Programming Languages

    CMSC 330: Organization of Programming Languages A Brief History of Programming Languages CMSC330 Fall 2020 Babylon • Founded roughly 4000 years ago – Located near the Euphrates River, 56 miles south of Baghdad, Iraq • Historically influential in ancient western world • Cuneiform writing system, written on clay tablets – Some of those tablets survive to this day – Those from Hammurabi dynasty (1800-1600 BC) include mathematical calculations • (Also known for Code of Hammurabi, an early legal code) A Babylonian Algorithm A [rectangular] cistern. The height is 3, 20, and a volume of 27, 46, 40 has been excavated. The length exceeds the width by 50. You should take the reciprocal of the height, 3, 20, obtaining 18. Multiply this by the volume, 27, 46, 40, obtaining 8, 20. Take half of 50 and square it, obtaining 10, 25. Add 8, 20, and you get 8, 30, 25 The square root is 2, 55. Make two copies of this, adding [25] to the one and subtracting from the other. You find that 3, 20 [i.e., 3 1/3] is the length and 2, 30 [i.e., 2 1/2] is the width. This is the procedure. – Donald E. Knuth, Ancient Babylonian Algorithms, CACM July 1972 The number n, m represents n*(60k) + m*(60k-1) for some k More About Algorithms • Euclid’s Algorithm (Alexandria, Egypt, 300 BC) – Appeared in Elements • See http://aleph0.clarku.edu/~djoyce/elements/bookVII/propVII2.html – Computes gcd of two integers let rec gcd a b = if b = 0 then a else gcd b (a mod b) • Al-Khwarizmi (Baghdad, Iraq, 780-850 AD) – Al-Khwarizmi Concerning the Hindu Art of Reckoning – Translated into
  • Facing up to Faults Brian Randell

    Facing up to Faults Brian Randell

    ReminiscencesReminiscences ofof WhetstoneWhetstone ALGOLALGOL Brian Randell DIKU, 30 September 2010 1 In Summer 1957 I had a vacation job at IBMIBM’s’s offices at 101 Wigmore Street, London These offices housed (and proudly displayed) an IBM 650 – their only computer in the UK DIKU, 30 September 2010 2 IBM 650 – a very successful and easy to program drumdrum-based-based decimal computer DIKU, 30 September 2010 3 In Autumn 1957 Mike Kelly and I arrived (from Imperial College) at English Electric Atomic Power Division, Whetstone, Leicestershire DIKU, 30 September 2010 4 Frank Whittle, inventor of the jet engine – whose Power Jet Company’sCompany’s factory was at Whetstone in WW2 DIKU, 30 September 2010 5 By the 1960s Whetstone was the site of EEEE’s’s Atomic Power Division (APD) and their Mechanical Engineering Laboratory (MEL) DIKU, 30 September 2010 6 In APD analogue computing was (at this time) ““king”king” – and the 15001500-amplifier-amplifier SATURN was being developed DIKU, 30 September 2010 7 We were hired to program nuclear reactor codes for APDAPD’s’s and MEL’sMEL’s first digital computer, a DEUCE DIKU, 30 September 2010 8 DEUCE was based on Pilot ACE, so inherited Alan TuringTuring’s’s cleverclever “optimum”“optimum” programming scheme DIKU, 30 September 2010 9 EASICODEEASICODE • DEUCE was difficult to program (well), and even more difficult to compile for. • Numerous interpreters were produced – and we invented a compromise scheme of “automatic programming” – EASICODE. • We nearly got fired because of it, but its success led to my becoming head of an Automatic Programming Section, with authority to “do something” for the upcoming KDF9.
  • Evolution of the Major Programming Languages Genealogy of Common Languages Zuse’S Plankalkül

    Evolution of the Major Programming Languages Genealogy of Common Languages Zuse’S Plankalkül

    CHAPTER 2 Evolution of the Major Programming Languages Genealogy of Common Languages Zuse’s Plankalkül • Designed in 1945, but not published until 1972 • Never implemented • Advanced data structures • floating point, arrays, records • Invariants Plankalkül Syntax • An assignment statement to assign the expression A[4] + 1 to A[5] | A + 1 => A V | 4 5 (subscripts) S | 1.n 1.n (data types) Minimal Hardware Programming: Pseudocodes • What was wrong with using machine code? • Poor readability • Poor modifiability • Expression coding was tedious • Machine deficiencies--no indexing or floating point Pseudocodes: Short Code • Short Code developed by Mauchly in 1949 for BINAC computers • Expressions were coded, left to right • Example of operations: 01 – 06 abs value 1n (n+2)nd power 02 ) 07 + 2n (n+2)nd root 03 = 08 pause 4n if <= n 04 / 09 ( 58 print and tab Pseudocodes: Speedcoding • Speedcoding developed by Backus in 1954 for IBM 701 • Pseudo ops for arithmetic and math functions • Conditional and unconditional branching • Auto-increment registers for array access • Slow! • Only 700 words left for user program Pseudocodes: Related Systems • The UNIVAC Compiling System • Developed by a team led by Grace Hopper • Pseudocode expanded into machine code • David J. Wheeler (Cambridge University) • developed a method of using blocks of re-locatable addresses to solve the problem of absolute addressing IBM 704 and Fortran • Fortran 0: 1954 - not implemented • Fortran I:1957 • Designed for the new IBM 704, which had index registers and floating point
  • Programming Languages: History and Future

    Programming Languages: History and Future

    Programming Languages: History and Future Jean E. Sammet IBM Corporation This paper discusses both the history and future of 1. Introduction programming languages (= higher level languages). Some of the difficulties in writing such a 1.1 Definition of Programming Languages history are indicated. A key part of the paper is a tree It is well known by now that there is no general showing the chronological development of languages agreement on the meaning of the term "programming and their interrelationships. Reasons for the prolifera- languages." In this paper the term is used interchange- tion of languages are given. The major languages are ably with "higher level languages," but even that does listed with the reasons for their importance. A section not solve the definition problem. Hence it is necessary on chronology indicates the happenings of the significant to specify that a programming language is considered previous time periods and the major topics of 1972. Key to be a set of characters and rules for combining them concepts other than specific languages are discussed. which have the following characteristics: (l) machine Key Words and Phrases: programming languages, code knowledge is unnecessary; (2) there is good poten- higher level languages, languages, history, future tial for conversion to other computers; (3) there is an directions, language interrelationships, programming instruction explosion (from one to many); and (4) language tree, programming language history, there is a notation which is closer to the original prob- programming language future lem than assembly language would be. CR Categories: 1.2, 4.2 1.2 Purpose and Scope of Paper Programming languages are almost as old as ACM, since the latter started in 1947 while the former started in 1952 with Short Code for UNIVAC.
  • Learning Algol 68 Genie

    Learning Algol 68 Genie

    LEARNING ALGOL 68 GENIE Algol 68 Genie 2.0.0 (September 2010) Edited by Marcel van der Veer Learning Algol 68 Genie copyright c Marcel van der Veer, 2008-2010. Algol 68 Genie copyright c Marcel van der Veer, 2001-2010. Learning Algol 68 Genie is a compilation of separate and independent documents or works, consisting of the following parts: I. Informal introduction to Algol 68, II. Programming with Algol 68 Genie, III. Example a68g programs, IV. Algol 68 Revised Report, V. Appendices Part I, II, III and V are distributed under the conditions of the GNU Free Documenta- tion License: Permission is granted to copy, distribute and / or modify the text under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled GNU Free Documentation License. See http://www.gnu.org. Part IV is a translation of the Algol 68 Revised Report into LATEX and is therefore subject to IFIP’s condition contained in that Report: Reproduction of the Report, for any purpose, but only of the whole text, is explicitly permitted without formality. Chapter 20, "Specification of partial parametrization proposal", is not a part of the Algol 68 Revised Report, and is distributed with kind permission of the author of this proposal, C.H. Lindsey. IBM is a trademark of IBM corporation. Linux is a trademark registered to Linus Torvalds. Mac OS X is a trademark of Apple Computer.
  • Principles of Programming Languages

    Principles of Programming Languages

    Principles of Programming Languages Lecture 02 Criteria for Language Design C SC 520 Principles of Programming Languages ↓ cut ↓ ↓ cut ↓ hhhhhhh hhhhhhh 1/7/106 AT&T FOIL 1 | | + + Criteria for Language Design 1. Simplicity — mnemonic — clear easily mastered semantics — as few basic concepts as possible — feature/concepts limited enough to master entire language (discourages "dialecting") — effects of feature combinations easily predictable — simple rules of combination ex: (1) PL/I: default coercion rules among fixed bin, fixed dec, float bin, float dec, when modified by scale attributes, become very complex. Each rule is reasonable by itself—the combination yields strange results. + + | | hhhhhhh hhhhhhh 1/7/106 AT&T FOIL 2 | | + + dcl M fixed dec(10,5), N fixed bin(5,4); N=0; M=N+.1; expr attr. repn. val. .1 dec(1,1) 0.1 (dec) 1/10 N+.1 bin(5,4) 0.0001|100110011 .. 1/16 (binary conversion, then truncation) M dec(10,5) 00000.06250 (dec) 1/16 (2) ALGOL 60: — own static — array dynamic size (known at block entry) ex: own boolean array B[M:N]; — created on first entry to block — retained between entries to block (with values at block exit) — seemingly could vary in size — conflicts with stack implementation — meaning? + + | | hhhhhhh hhhhhhh 1/7/106 AT&T FOIL 3 | | + + (3) PASCAL: fairly simple (4) ADA: Entia non sint multiplicanda praeter necessitatem —William of Ockham — procedure calls: keyword or positional for actual/formal correspondence — but positional parameters must occur first, and once a keyword is used, rest of the call must use keyword parms REORDER_KEYS(NUM_OF_ITEMS, KEY_ARRAY :=: RESULT_TABLE); + + | | hhhhhhh hhhhhhh 1/7/106 AT&T FOIL 4 | | + + 2.
  • Dijkstra's Crisis

    Dijkstra's Crisis

    Dijkstra’s Crisis: The End of Algol and Beginning of Software Engineering, 1968-72 Thomas Haigh, [email protected], www.tomandmaria.com/tom Draft for discussion in SOFT-EU Project Meeting, September 2010 “In SHOT meetings and in the journals, it is surprising how few and far between critical references to specific historical arguments are: there is hardly any debate or even serious substantive disagreement.” – David Edgerton, 2010. In 1968 a NATO Software Engineering Conference was held in Garmisch, Germany. Attendees represented a cross section of those involved in programming work and its management. Having never met before they were shocked to realize that identical troubles plagued many different kinds of software. Participants agreed that a “software crisis” was raging. Programming projects were chronically late and over budget, yet often failed to produce useful software. They endorsed a new discipline of software engineering, its contents yet to be defined, as the solution to this crisis. A follow up conference, held in Rome the next year, failed to reach consensus on what specific techniques might constitute the core of this new discipline. Yet software engineering soon became the dominant identity to describe the work and management of programmers. That, at least, is the composite account one would gain from the almost identical paragraphs repeated again and again in historical works both scholarly and popular. But this growing mass of consensus is, I believe, built on sand. The historical significance of the 1968 NATO Conference, the demographics of its participants, its connection to prior and subsequent events, and its relationship to the software crisis are at risk of being fundamentally misinterpreted.
  • How to Call Procedures, Or Second Thoughts on Ackermann's Function

    How to Call Procedures, Or Second Thoughts on Ackermann's Function

    SOFTWARE-PRACTICE AND EXPERIENCE, VOL. 7, 317-329 (1977) How to Call Procedures, or Second Thoughts on Ackermann’s Function B. A. WICHMANN National Physical Laboratory, Teddington, Middlesex TlVI I OL W,England SUMMARY Various problems have been encountered in using Ackermann’s function to measure the efficiency of procedure calls in System Implementation Languages. Although measurements have been made of some 60 systems, the ones presented here are included only when com- parisons are possible. For conventional machine design, it is possible to draw some con- clusioiis on desirable instruction set features. A surprising result from the analysis is that implementation quality is far more important than the overheads implied by language design. KEY WORDS Procedure call Recursion Efficiency System Implementation Languages INTRODUCTION In the design of System Impletnentation Languages, efficiency is a prime consideration because otherwise programmers will be forccd to use conventional assembly languages. It is well known that procedure calling in conventional high-level languages is relatively expensive, and hence this aspect of System Implementation 1,anguages (SILs) is \rorth special attention. Measurcrnents using Ackermann’s function have been made with this in mind.‘ In this paper comparisons are made between the implementations on the same machine architecture by examination of the machine code produced. Several machine architectures are also compared for their suitability as target machines for recursive languages. The architectures chosen for this study are the IBM 360/370, ICL 1900, DEC PDP11, DECIO, Burroughs stack machines and the CDC Cyber Series. Although other results have been obtained, further analysis is not, in general, worthwhile due to the lack of comparative data on the same architecture.
  • Revised Report on the Algorithmic Language ALGOL 68 Edited By: A

    Revised Report on the Algorithmic Language ALGOL 68 Edited By: A

    Revised Report on the Algorithmic Language ALGOL 68 Edited by: A. van Wijngaarden, B.J. Mailloux, J.E.L. Peck, C.H.A. Koster, M. Sintzoff, C.H. Lindsey, L.G.T. Meertens and R.G. Fisker. This Report has been accepted by Working Group 2.1, reviewed by Technical Committee 2 on Programming and approved for publication by the General Assembly of The International Federation for Information Processing. Re- production of the Report, for any purpose, but only of the whole text, is explicitly permitted without formality. The translation 1.1.5 of the Report to TEX source language was created by: f W.g B. Kloke, mailto:[email protected] . Remarks on this edition are collected into a separated document, http://vestein.arb-phys.uni-dortmund.de/~ wb/RR/vorwort.tex. Further versions will be found also in http://vestein.arb-phys.uni- dortmund.de/~ wb/RR/. The table of contents had to be removed, because page numbers are not a valid concept in TEX source language. Known errata, as published in Algol Bulletin No. 41 and ::: , are cor- rected. Syntactic errors in the standard-prelude, as mentioned in Commen- tary AB 43 p.7f, are corrected also. The Partial Parametrization Proposal (AB39.3.1) has been appended to the text. Layout of examples may still be improved. 1 Section ALGOL 68 Revised Report Acknowledgements Habent sua fata libelli. f De litteris Terentianus Maurus g Working Group 2.1 on ALGOL of the International Federation for Infor- mation Processing has discussed the development of \ALGOL X", a succes- sor to ALGOL 60 [3] since 1963.