Algorithmic Language and Program Development

0.1 On the Etymology of the Word Algorithm.- 0.2 How Algorithms are Characterized.- 0.3 Programming as an Evolutionary Process.- 0.4 How to Solve it.- 1. Routines.- 1.1 The Parameter Concept.- 1.2 Declaration of a Routine.- 1.3 Hierarchical Construction of Routines.- 1.3.1 Primitive Routines and Computational Structures.- 1.3.2 The Principle of Substitution.- 1.3.3 Alternatives.- 1.3.4 Input/Output.- 1.4 Recursive Routines and Systems.- 1.4.1 Examples.- 1.4.2 Proof of Termination.- 1.4.3 Taxonomy of Recursion.- 1.4.4 The Level of Applicative Formulation.- 1.5 Mathematical Semantics: Fixpoint Theory.- 1.5.1 Recursive Routines and Functional Equations.- 1.5.2 Fixpoint Theory.- 1.6 Proofs by Induction of Properties of Routines.- 1.6.1 Computational Induction.- 1.6.2 Structural Induction.- 1.7 Operational Semantics: Machines.- 1.7.1 Unfolding and Folding.- 1.7.2 Partial Computation.- 1.7.3 Text Substitution Machines.- 1.7.4 The Stack Machine.- 1.8 Restriction of the Parameter Domain.- 1.9 Dijkstra's Guards.- 1.10 Pre-Algorithmic Formulations by Means of Choice and Determination.- 1.10.1 The Choice Operator.- 1.10.2 The Determination Operator.- 1.11 Semantics of Non-Deterministic Constructions.- 1.11.1 Pre-Algorithms and Algorithms.- 1.11.2 Deriving Algorithms from Pre-Algorithms.- 1.11.3 Mathematical Semantics of Non-Determinate Routines.- 1.11.4 Operational Semantics of Non-Deterministic Algorithms.- 1.12 Routines with a Multiple Result.- 1.13 Structuring of Routines.- 1.13.1 Structuring by Means of Abstraction and Embedding.- 1.13.2 Segments and Suppressed Parameters.- 1.13.3 Object Declarations.- 1.13.4 Result Parameters and the Actualization Taboo.- 1.14 Routines as Parameters and Results.- 1.14.1 Routines as Results.- 1.14.2 Functional Programming.- 1.14.3 The Delay Rule.- Addendum: Notations.- 2. Objects and Object Structures.- 2.1 Denotations.- 2.2 Scope of a Freely Chosen Designation.- 2.3 Kinds of Objects.- 2.4 Sets of Objects, Modes.- 2.5 Composite Modes and Objects.- 2.6 Selectors, Structures with Direct (Selector) Access.- 2.6.1 Compounds.- 2.6.2 Arrays.- 2.6.3 The Selection Structure of Compound and Array.- 2.7 Mode Variants.- 2.8 Introduction of New Modes: Summary.- 2.9 Recursive Object Structures.- 2.9.1 Definition of Recursive Object Structures.- 2.9.2 Object Diagrams.- 2.9.3 Operational Detailing of Objects.- 2.10 Algorithms with Linear Object Structures.- 2.11 The Recursive Object Structure "File".- 2.11.1 "Knitting" of Sequences.- 2.11.2 Files.- 2.12 Algorithms with Cascade-Type Object Structures.- 2.13 Traversal and Scanning of Recursive Object Structures.- 2.14 Infinite Objects.- 2.14.1 Nexuses of Objects.- 2.14.2 Lazy Evaluation.- 2.15 Some Peculiarities of Arrays.- 2.15.1 Arrays with Computed Index Bounds.- 2.15.2 Induced Operations for Arrays.- 2.16 Routines with Multiple Results Revisited.- Addendum: Notations.- 3. Computational Structures.- 3.1 Concrete Computational Structures.- 3.1.1 Encapsulation Effect.- 3.1.2 Properties of Operations.- 3.1.3 Definition of Concrete Computational Structures.- 3.1.4 Atomic Examples.- 3.2 Abstract Computational Structures and Abstract Types.- 3.2.1 Fundamental Concepts.- 3.2.2 Semantics of Abstract Computational Structures and Abstract Types.- 3.2.3 Completeness of Properties.- 3.2.4 Concretization of an Abstract Type.- 3.2.5 Notation and First Examples.- 3.2.6 Constructors and Selectors.- 3.3 Abstract Arrays.- 3.3.1 One-Side-Flexible Arrays.- 3.3.2 Two-Side-Flexible Arrays.- 3.3.3 Aggregates.- 3.4 Sequence-Type Computational Structures.- 3.4.1 Stack, Deck and Queue.- 3.4.2 Excursus: Divisibility Theory in Semi-Groups.- 3.4.3 Sequence and Word.- 3.4.4 Forgetful Functors.- 3.4.5 Sets.- 3.5 Number-Type Computational Structures.- 3.5.1 Peano Numbers.- 3.5.2 Cycle Numbers and Natural Numbers.- 3.5.3 Excursus: Extension by Means of Formal Quotients.- 3.5.4 Integers.- 3.5.5 Rational Numbers.- 3.5.6 Positional Systems and B-al-Fractions.- 3.6 Changing Abstract Types and Object Structures.- 3.6.1 Type Change and Related Types.- 3.6.2 Concretization.- 3.6.3 Implementation of Concrete Computational Structures.- 3.6.4 Example: Binarization.- 3.6.5 Example: Packing of Objects.- Addendum: Notations.- 4. Transformation into Repetitive Form.- 4.1 Schemes and Transformations.- 4.2 Treatment of Linear Recursion.- 4.2.1 The Technique of Re-Bracketing.- 4.2.2 The Technique of Operand Commutation.- 4.2.3 Function Inversion.- 4.2.4 Function Inversion According to Paterson and Hewitt.- 4.2.5 Function Inversion by Introducing Stacks.- 4.3 Treatment of Non-Linear Recursions.- 4.3.1 Method of Functional Embedding.- 4.3.2 Arithmetization of the Flow of Control.- 4.3.3 Special Cases of Nested Recursion.- 4.3.4 The Technique of Range-of-Values Tabulation.- 4.4 Disentanglement of the Control.- 4.4.1 Disentangled Routines.- 4.4.2 Disentangling Recursive Routines by Means of Function Inversion.- 4.4.3 Reshaping the Type of Control Flow.- 5. Program Variables.- 5.1 The Origin of Program Variables.- 5.1.1 Specialization of the Stack Machine.- 5.1.2 Specialization of the Range-of-Values Machine.- 5.2 Formal Introduction of Program Variables.- 5.2.1 Sequentialization of Object Declarations.- 5.2.2 Program Variables as a Means for Saving Identifiers.- 5.2.3 Expressions with Side-Effects.- 5.2.4 Complete Sequentialization of Collective Assignments.- 5.3 Procedures.- 5.3.1 Program Variables as Parameters.- 5.3.2 Actualization Taboo, Alias Ban and Suppressed Variable Parameters.- 5.3.3 Sharing of Variables.- 5.3.4 Initialization.- 5.3.5 Properties of Program Variables.- 5.4 Axiomatic Description of Programming Languages.- 5.4.1 Predicate Transformers.- 5.4.2 Program Verification.- 5.5 Variables for Structured Objects.- 5.5.1 Selective Alteration.- 5.5.2 Remarks on Input/Output.- Addendum: Notations.- 6. Control Elements.- 6.1 Deparameterization and Formal Treatment of Repetition.- 6.1.1 Deparameterization.- 6.1.2 Semantics of Repetition.- 6.1.3 Analytical Treatment of the Protocol Stack.- 6.2 Jumps.- 6.2.1 Simple Call as a Basic Control Element.- 6.2.2 Introduction of Jumps.- 6.3 The General do-od Construction.- 6.4 Loops.- 6.4.1 Rejecting and Non-Rejecting Repetition.- 6.4.2 Counted Repetition.- 6.5 Loops and Repetitive Systems.- 6.6 Sequential Circuits.- 6.7 Flow Diagrams.- 6.7.1 Classical Flow Diagrams.- 6.7.2 Splitting and Collection.- 6.7.3 Coordinated Flow Diagrams.- 6.8 Petri Nets.- 6.8.1 Theory of Petri Nets.- 6.8.2 Construction of Petri Nets, Connection to Coordinated Flow Diagrams.- 6.9 bool Petri Nets, Signals.- 6.10 nat Petri Nets, Semaphores.- Addendum: Notations.- 7. Organized Storages and Linked Lists.- 7.1 Organized Storages.- 7.1.1 Selective Updating.- 7.1.2 Collecting and Composing Variables.- 7.1.3 Computed Variables.- 7.1.4 Constructing Organized Storages and Generating Variables.- 7.1.5 Advantages and Disadvantages of Organized Storages.- 7.2 Identity of Variables and Alias Ban Revisited.- 7.2.1 Revision of the Assignment Axiom.- 7.2.2 Checking the Actualization Taboo.- 7.3 Implementing Object Structures by Organized Storages.- 7.4 Linked-List Implementation of Organized Storages.- 7.4.1 References to Variables: Pointers.- 7.4.2 Wirth's Connection.- 7.4.3 Link Variables.- 7.4.4 Implementing Computational Structures Using Linked Lists.- 7.4.5 Properties of Pointers.- 7.5 Improvement of Algorithms Working on Linked Lists by Selective Updating.- 7.5.1 Algorithms for One-Way Linked Lists.- 7.5.2 Algorithms for Two-Way Linked Lists.- 7.6 Addressing.- 7.6.1 Addresses for Variables.- 7.6.2 Jump Addresses.- 7.6.3 Genuine Addresses.- 7.6.4 Outlook to Systems Programming.- Addendum: Notations.- Conclusion. Programming as an Evolutionary Process.- Program Specification and Development in a Uniform Language.- Conceptual Organization of the Algorithmic Language.- Tools to Be Used.- Methodology of Programming.

[1]  William A. Wulf,et al.  BLISS: a language for systems programming , 1971, CACM.

[2]  H. Bottenbruch,et al.  Übersetzung von algorithmischen Formelsprachen in die Programmsprachen von Rechenmaschinen , 1958 .

[3]  C. A. R. Hoare,et al.  A Theory of Nondeterminism , 1980, ICALP.

[4]  Daniel P. Friedman,et al.  CONS Should Not Evaluate its Arguments , 1976, ICALP.

[5]  R. Bayer,et al.  Organization and maintenance of large ordered indices , 1970, SIGFIDET '70.

[6]  Niklaus Wirth,et al.  On the Design of Programming Languages , 1974, IFIP Congress.

[7]  J. W. de Bakker,et al.  Semantics and Termination of Nondeterministic Recursive Programs , 1976, ICALP.

[8]  George Radin,et al.  NPL: highlights of a new programming language , 1965, CACM.

[9]  Manfred Broy,et al.  Semantics of Nondeterministic and Noncontinuous Constructs , 1978, Program Construction.

[10]  John Darlington,et al.  A system which automatically improves programs , 1973, Acta Informatica.

[11]  Stephen N. Zilles,et al.  Specification techniques for data abstractions , 1975 .

[12]  Peter J. Denning,et al.  Sacrificing the calf of flexibility on the altar of reliability , 1976, ICSE '76.

[13]  Niklaus Wirth,et al.  EULER: a generalization of ALGOL, and its formal definition: Part II , 1965, CACM.

[14]  Klaus J. Berkling.  Reduction languages for reduction machines , 1974, ISCA '75.

[15]  H. R. Strong.  Translating Recursion Equations into Flow Charts , 1971, J. Comput. Syst. Sci..

[16]  Peter Pepper,et al.  A Study on Transformational Semantics , 1978, Program Construction.

[17]  Jean Vuillemin.  Syntaxe, sémantique et axiomatique d'un langage de programmation simple , 1975 .

[18]  Jean Vuillemin.  Correct and Optimal Implementations of Recursion in a Simple Programming Language , 1974, J. Comput. Syst. Sci..

[19]  Robert D. Tennent,et al.  The denotational semantics of programming languages , 1976, CACM.

[20]  Tony Hoare,et al.  Notes on Data Structuring , 1972 .

[21]  Allen Newell,et al.  An introduction to information processing language V , 1960, Commun. ACM.

[22]  B. J. Mailloux,et al.  Report of Algorithmic Language ALGOL 68 , 1969 .

[23]  Joseph E. Stoy,et al.  Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory , 1981 .

[24]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[25]  Manfred Broy,et al.  Programming languages as abstract data types , 1980, CLAAP.

[26]  T. KILBURN.  The University of Manchester Universal High-Speed Digital Computing Machine , 1949, Nature.

[27]  Manfred Broy.  Transformation parallel ablaufender Programme , 1980 .

[28]  John V. Guttag,et al.  The specification and application to programming of abstract data types. , 1975 .

[29]  Werner Damm,et al.  On the Power of Self-Application and Higher Type-Recursion , 1978, ICALP.

[30]  David Gries.  The Multiple Assignment Statement , 1978, Program Construction.

[31]  Jay Earley.  Toward an understanding of data structures , 1970 .

[32]  Rod M. Burstall,et al.  Proving Properties of Programs by Structural Induction , 1969, Comput. J..

[33]  Terrence W. Pratt.  A hierarchical graph model of the semantics of programs , 1969, AFIPS '69 (Spring).

[34]  B. C. Carlson.  Algorithms Involving Arithmetic and Geometric Means , 1971 .

[35]  David Gries,et al.  Current Ideas in Programming Methodology , 1976, Program Construction.

[36]  Peter Henderson,et al.  Functional programming - application and implementation , 1980, Prentice Hall International Series in Computer Science.

[37]  Laszlo A. Belady,et al.  A Study of Replacement Algorithms for Virtual-Storage Computer , 1966, IBM Syst. J..

[38]  John C. Reynolds,et al.  GEDANKEN—a simple typeless language based on the principle of completeness and the reference concept , 1970, Commun. ACM.

[39]  Robert W. Floyd,et al.  Assigning meaning to programs , 1967 .

[40]  Craig Schaffert,et al.  Abstraction mechanisms in CLU , 1977 .

[41]  Martin D. Davis,et al.  Computability and Unsolvability , 1959, McGraw-Hill Series in Information Processing and Computers.

[42]  Ken Kennedy,et al.  An introduction to the set theoretical language SETL , 1975 .

[43]  S. C. Kleene,et al.  Introduction to Metamathematics , 1952 .

[44]  Heinz Rutishauser,et al.  Description of Algol 60 , 1967 .

[45]  Robert M. Graham,et al.  Principles of Systems Programming , 1975 .

[46]  C. A. R. Hoare,et al.  A contribution to the development of ALGOL , 1966, CACM.

[47]  Niklaus Wirth,et al.  Program development by stepwise refinement , 1971, CACM.

[48]  D. C. Cooper.  The Equivalence of Certain Computations , 1966, Comput. J..

[49]  David Lorge Parnas.  On a solution to the cigarette smokers' problem , 1972 .

[50]  D. A. Turner,et al.  A new implementation technique for applicative languages , 1979, Softw. Pract. Exp..

[51]  Zohar Manna,et al.  PROPERTIES OF PROGRAMS AND PARTIAL FUNCTION LOGIC , 1969 .

[52]  Dana S. Scott,et al.  Data Types as Lattices , 1976, SIAM J. Comput..

[53]  Carl Hewitt,et al.  Comparative Schematology , 1970 .

[54]  J. W. Backus.  The History of FORTRAN I, II and III , 1979, IEEE Ann. Hist. Comput..

[55]  Hans Langmaack,et al.  Informatik - Programmierung , 1973, Teubner Studienbücher: Informatik.

[56]  Jacob T. Schwartz,et al.  On programming : an interim report on the SETL Project , 1973 .

[57]  Heinz Schecher.  Manahmen zur Vereinfachung von Rechenplnen bei elektronischen Rechenanlagen , 1956 .

[58]  M. Griffiths,et al.  Program production by successive transformation , 1975, Language Hierarchies and Interfaces.

[59]  Rudolf Bayer,et al.  Binary B-trees for virtual memory , 1971, SIGFIDET '71.

[60]  Friedrich L. Bauer,et al.  Algorithms and algebra , 1979, Algorithms in Modern Mathematics and Computer Science.

[61]  Gerhard Seegmüller.  Systems Programming as an Emerging Discipline , 1974, IFIP Congress.

[62]  A. Church.  The calculi of lambda-conversion , 1941 .

[63]  Jeffrey D. Ullman,et al.  Formal languages and their relation to automata , 1969, Addison-Wesley series in computer science and information processing.

[64]  John R. Myhill,et al.  Criteria of constructibility for real numbers , 1953, Journal of Symbolic Logic.

[65]  Stanley Gill,et al.  Automatic computing: its problems and prizes , 1965, Comput. J..

[66]  Michael J. C. Gordon.  Operational reasoning and denotational semantics. , 1975 .

[67]  Rózsa Péter.  Rekursive Funktionen in der Komputer-Theorie , 1976 .

[68]  Kristen Nygaard,et al.  SIMULA: an ALGOL-based simulation language , 1966, CACM.

[69]  Joseph A. Goguen,et al.  Putting Theories Together to Make Specifications , 1977, IJCAI.

[70]  Edsger W. Dijkstra,et al.  Guarded commands, nondeterminacy and formal derivation of programs , 1975, Commun. ACM.

[71]  Niklaus Wirth,et al.  Systematic Programming: An Introduction , 1974 .

[72]  P. J. Landin,et al.  The next 700 programming languages , 1966, CACM.

[73]  M. AdelsonVelskii,et al.  AN ALGORITHM FOR THE ORGANIZATION OF INFORMATION , 1963 .

[74]  David J. Farber,et al.  SNOBOL , A String Manipulation Language , 1964, JACM.

[75]  William W. Wadge,et al.  Lucid - A Formal System for Writing and Proving Programs , 1976, SIAM J. Comput..

[76]  Gian-Carlo Rota,et al.  The real numbers as a wreath product , 1975 .

[77]  Carl Hewitt,et al.  Viewing Control Structures as Patterns of Passing Messages , 1977, Artif. Intell..

[78]  David Gries.  Programming Methodology: A Collection of Articles by Members of IFIP WG 2.3 , 1978 .

[79]  Andrei P. Ershov,et al.  On the Essence of Compilation , 1977, Formal Description of Programming Concepts.

[80]  A. vanWijngaarden.  Recursive definition of syntax and semantics : (proceedings ifip working conference on formal language description languages, vienna 1966, p 13-24) , 1966 .

[81]  Herman H. Goldstine,et al.  Planning and coding of problems for an Electronic Computing Instrument , 1947 .

[82]  Manfred Broy,et al.  Semantic Relations in Programming Languages , 1980, IFIP Congress.

[83]  John W. Backus,et al.  Can programming be liberated from the von Neumann style?: a functional style and its algebra of programs , 1978, CACM.

[84]  G. Steele.  Macaroni is better than spaghetti , 1977, Artificial Intelligence and Programming Languages.

[85]  Tony Hoare,et al.  Hierarchical Program Structures , 1972 .

[86]  John F. Wakerly,et al.  The programming language PASCAL , 1979, Microprocessors and microsystems.

[87]  Mary Shaw,et al.  An introduction to the construction and verification of Alphard programs , 1976, ICSE '76.

[88]  H. Gordon Rice,et al.  Recursion and iteration , 1965, Commun. ACM.

[89]  Wolfram-Manfred Lippe,et al.  Semantics for LISP without Reference to an Interpreter , 1980, Symposium on Programming.

[90]  Kenneth E. Iverson,et al.  A programming language , 1899, AIEE-IRE '62 (Spring).

[91]  A. Turing.  On Computable Numbers, with an Application to the Entscheidungsproblem. , 1937 .

[92]  Allen Newell,et al.  The logic theory machine-A complex information processing system , 1956, IRE Trans. Inf. Theory.

[93]  P. Wynn,et al.  On a device for computing the _{}(_{}) tranformation , 1956 .

[94]  Maurice V. Wilkes,et al.  Some proposals for improving the efficiency of ALGOL 60 , 1961, CACM.

[95]  Manfred Broy,et al.  Abstract Data Types as Lattices of Finitely Generated Models , 1980, MFCS.

[96]  Per Brinch Hansen,et al.  Distributed processes: a concurrent programming concept , 1978, CACM.

[97]  R. Haskell.  Efficient Implementation of a Class of Recursively Defined Functions , 1975, Comput. J..

[98]  Edsger W. Dijkstra.  A simple axiomatic basis for programming language constructs , 1973 .

[99]  Friedrich L. Bauer,et al.  The “Plankalkül” of Konrad Zuse: a forerunner of today's programming languages , 1972, CACM.

[100]  Dana S. Scott,et al.  Outline of a Mathematical Theory of Computation , 1970 .

[101]  Donald E. Knuth,et al.  Structured Programming with go to Statements , 1974, CSUR.

[102]  Niklaus Wirth,et al.  Algorithms + Data Structures = Programs , 1976 .

[103]  Gunther Schmidt,et al.  Programs as Partial Graphs I: Flow Equivalence and Correctness , 1981, Theor. Comput. Sci..

[104]  Dana S. Scott,et al.  Lectures on a Mathematical Theory of Computation , 1982 .

[105]  John Darlington,et al.  A Transformation System for Developing Recursive Programs , 1977, J. ACM.

[106]  Daniel G. Bobrow,et al.  A Comparison of List-Processing Computer Languages , 1963 .

[107]  Claus-Peter Schnorr.  Refined Analysis and Improvements on Some Factoring Algorithms , 1982, J. Algorithms.

[108]  Arthur J. Bernstein,et al.  Analysis of Programs for Parallel Processing , 1966, IEEE Trans. Electron. Comput..

[109]  C. A. R. Hoare,et al.  An Axiomatic Definition of the Programming Language PASCAL , 1973, Acta Informatica.

[110]  C. A. R. HOARE,et al.  An axiomatic basis for computer programming , 1969, CACM.

[111]  Martin Richards,et al.  BCPL: a tool for compiler writing and system programming , 1969, AFIPS '69 (Spring).

[112]  Brian A. Wichmann,et al.  Rationale for the design of the Ada programming language , 1979, SIGP.

[113]  S. Rao Kosaraju,et al.  Limitations of Dijkstra's Semaphore Primitives and Petri nets , 1973, SOSP '73.

[114]  J. W. de Bakker,et al.  Semantics of Programming Languages , 1969 .

[115]  Joseph A. Goguen,et al.  Initial Algebra Semantics and Continuous Algebras , 1977, J. ACM.

[116]  Friedrich L. Bauer,et al.  Programming in a Wide Spectrum Language: A Collection of Examples , 1981, Sci. Comput. Program..

[117]  Gerald Jay Sussman,et al.  The Art of the Interpreter or, The Modularity Complex (Parts Zero, One, and Two) , 1978 .

[118]  Jack B. Dennis,et al.  Concurrency in Software Systems , 1972, Advanced Course: Software Engineering.

[119]  Manfred Broy,et al.  Theoretical Foundations of Programming Methodology , 1982 .