Programming Languages

Literature references and annotations by Dick Grune,
Last update: Sat Nov 19 17:10:00 2022.

These references and annotations were originally intended for personal use and are presented here only in the hope that they may be useful to others. There is no claim to completeness or even correctness. Each annotation represents my understanding of the text at the moment I wrote the annotation.
No guarantees given; comments and content criticism welcome.

* Simon Thompson, Haskell: The Craft of Functional Programming, Addison-Wesley, Harlow, UK, 1999, pp. 487.
After an easy-paced 7-chapter introduction to Haskell and its implementation Hugs, the link between program development and correctness proof is emphasized in Chapter 8. Chapters 9 to 17 cover increasingly more advanced subjects (including overloading, algebraic types, abstract data types, lazy evaluation, and I/O), culminating in an understandable explanation of monads. An appendix compares functional programming with imperative and object-oriented.

* Tim Lindholm, Frank Yellin, The Java Virtual Machine Specification, (2nd Edn.), Addison-Wesley, Reading, Ma., 1999/1997, pp. ???.
That, plus the class file format, plus advice on compiling for the Java Virtual Machine, plus advice on thread and locks.

* John Lewis, William Loftus, Java -- Software Solutions -- Foundations of Program Design, Addison-Wesley, Reading, Mass., 1998, pp. 857.
Combined and parallel explanation of introductory computer science, Java, basic algorithms, computer and network technology, GUIs, etc. Very American, contains a whopping 300 pages of Appendices.

* Charles F. Goldfarb, Paul Prescod, The XML Handbook, Prentice Hall PTR, Upper Saddle River, NJ 07458, 1998, pp. 639.
Extensive but rather oddly structured explanation of many aspects of XML: philosophy, basics, syntax, style sheets, applications, etc.

* Jeff Holtzman, XML update, C++ Builder, and more, Electronics Now, vol. 69, #8, Aug. 1998, pp. 16,25.
Discussion of some books on XML.

* Jeff Holtzman, XML: Who controls the DTD?, Electronics Now, vol. 69, #7, July 1998, pp. 25,26,30.
Very palatable introduction to XML, newspaper-style. Emphasizes the fact that XML is a streamlined SGML.

* Eli Willner, Preparing data for the Web with SGML / XML, Part I/II/III, Information Today, vol. 15, #5/6/7, May/June/July 1998, pp. 54/52-54/39,42.
Explanation of SGML/XML, reasons to convert. Good advice about and seven golden rules for converting to SGML/XML.

* H.M. Deitel, P.J. Deitel, Java How to Program -- with an Introduction to Visual J++, Pentice Hall, Upper Sadle River, NJ 07458, 1997, pp. 1114.
Massive and sometimes overwhelming exposition of the subject, of a mixed nature: partly Java text book and partly introduction to programming language principles, data structures and concurrent programming. Full of examples and of an inimitable style; most of the examples are interactive and window-oriented. Tons of good advice. Still, some ways of presentation may give the student a wrong impression. Examples are the use of the term "syntax error" for any error the compiler can spot including context errors, and presenting the while statement before the for statement; the latter may be in principle correct in Java, but gives a funny slant on programming.

* Bjarne Stroustrup, The C++ Programming Language, (3rd Edn.), Addison-Wesley, Reading, Mass., 1997, pp. 910.
Massive description of the language, in four parts: basic facilities, abstraction mechanisms, standard library, and design using C++. Full of examples, details and programming advice.

* Ed Anuff, The Java Source Book, John Wiley, New York, 1996,
[ -.00050.IR ]

* Ken Arnold, James Gosling, The Java Programming Language, Addison-Wesley, Reading, Mass., 1996, pp. 329.
Reasonably down to earth explanation of the language, its features and its applicability. Full of examples; occasional exercises.

* James Gosling, Bill Joy, Guy Steele, The Java Language Specification, Addison-Wesley, Reading, Mass., 1996, pp. 825.
Detailed exposition of same; not as boring as it might have been. Includes advice on naming, conventions to be followed, etc.
     By manipualting the paper thickness, the publishers have managed to give all books in this series about equal width, although some differ by more than a factor of two in page numbers.

* Chris Houser, Manual and compiler for the terse and modular language DEM, ACM SIGPLAN Notices, vol. 31, #12, Dec. 1996, pp. 41-51.
DEM is a subset of Demeter (Lieberherr) with a very terse syntax. It has a large number of defaults built in, which is the main source of its terseness. The compiler is indeed there, in 100 lines of Perl; it translates to C++.

* Melvyn King, John Pardoe, Paul Vickers, A First Course in Computer Programming Using C, McGraw-Hill, London, 1995, pp. 242.
The book seems indeed suitable for absolute beginners, as far as these things can be determined without class room testing. The explanations are clear and cover much ground. Whether it is wise to treat the while loop before the for-loop is not immediately clear; actually it might make sense.

* Brian Harvey, Computer Science, Logo Style, MIT Press, Cambridge, Mass., Feb. 1997, pp. 1068.
Volume 1: Symbolic Computing; Volume 2: Advanced Techniques; Volume 3: Beyond Programming.

* Eric van Herwijnen, Practical SGML, (2nd Edn.), Kluwer Academic Publishers, Boston, 1994, pp. 288.
Extensive and personal though sometimes erratic description of SGML, clearly written by an opiniated enthousiast. Full of information, advice, tidbits of knowledge, examples and exercises, all arranged around a few phrases from Orwell's Aminal Farm.
     SGML is explained completely in its own particular terminology, so the book does nothing to reduce the gap between SGML and computer science.

* Colin Charlton, Paul Leng, Janet Little, A Course on C, McGraw-Hill, London, 1993, pp. 233.
The book is unusual in that it introduces debugging, using tools, right from the start; how this reflects in C remains to be seen:-) Initially, the book addresses absolute beginners and the authors make a discernible effort to address the ignorant as normal people. The book then progressively covers more material, arrays, arrays of arrays, structs, linked lists, trees, to end with an entire chapter on pointers to functions. The compilation process and standard libraries are covered extensively. The scope rules, notorious in C, are explained twice, once in the introduction where they are simplified so as to verge on the incorrect, and further on, where the explanation is essentially correct.
     Enough material for a solid course in C.
     The lazy nature of the && and || is not explained; hex constants are shown but not explained.

* A. Oram, S. Talbott, Managing Projects with make, O'Reilly & Associates, Sebastopol CA, 1993, pp. 149.
Includes extensive description of suffix rules, project management, comparison of various makes.

* J.E. Cooling, N. Cooling, J. Cooling, Introduction to Ada, Chapman & Hall, London, 1993, pp. 605.
Entertaining and yet thorough text book on Ada. Covers methodological issues where useful; explains fully the need for high-level languages, structuring, constant declarations, arrays, etc. Full of amusing and instructive cartoons, typographically well supported, though perhaps somewhat loud. Definitely a good book to learn Ada from, if you're not a techofreak. Full treatment of the language, including generics, tasks, I/O and some pragmas. Less bone dry than Barnes, but perhaps sometimes too explicit.

* C.J. Date, Hugh Darwen, A Guide to the SQL Standard, (3rd Edn.), Addison-Wesley, Reading, Mass., 1993, pp. 414.
Heavily footnoted full coverage of an increasingly complex language. Not for beginners.

* Keith Tizzard, C for Professional Programmers, (2nd Edn.), Simon & Schuster, 1992, pp. .

* Dale Dougherty, sed & awk, O'Reilly & Associates, Sebastopol CA, 1992, pp. 397.
Pages 1-140: sed; 141-315: awk/nawk; 316-397: Quick References.

* Antony J.T. Davie, An Introduction to Functional Programming Systems using Haskell, Cambridge Computer Science Texts, #27, Cambridge University Press, Cambridge, UK, 1992, pp. 290.
The book fully supports the title: functional programming is explained with some zeal in densely written prose, using Haskell as the vehicle. Consequently, it also treats concepts not found in Haskell, e.g. data laws. Some subjects are: polymorphic and algebraic types, lambda calculus, normal forms, reduction order, lazy evaluation and correctness proofs. The full range of functional programming applications is covered, including OS interaction and parallel processing. Implementation problems and existing projects are also discussed.
     See also review by Reginald Meeson, ACM SIGPLAN Notices, 27, #11, p. 11, Nov. 1992.

* Martin Reiser, Niklaus Wirth, Programming in Oberon: Steps beyond Pascal and Modula, ACM Press, Addison-Wesley, Reading, Mass., 1992, pp. 320.
Very roughly, Oberon is Modula-2 minus the low-level features plus type extension. Better than most Wirth books.

* Larry Wall, Randal L. Schwartz, Programming Perl, Nutshell Handbook, O'Reilly, Sebastopol, Ca., 1992, pp. 465.
Extensive; with candid chapter titles like "The Gory Details". Many worked examples.

* S. Tucker Taft, Ada 9X: a technical summary, Commun. ACM, vol. 35, #11, pp. 77-82. Nov. 1992,
Ada 9X is expected to have the following new features:
     -- Access types to subprograms (it seems to me that the X in Ada 9X may be there because 9X resulted from failed attempts to implement X Windows in Ada 83).
     -- Extended types: add components during new types definitions: type Y is new X with record ... end record; this gives single inheritance.
     -- Types have a new attribute &'CLASS which is the set of all types extended from it. To be used for parameters to polymorphic subprograms. The run-time system maintains type information to find the proper subprograms dynamically.
     -- Library unit names form a tree-structured name space.
     -- Programs can consist of "partitions", each with a separate address space, communicating via shared packages and/or RPC.
     -- Protected types: types with built-in exclusive access and entry barriers for the operations.

* Richard Mitchell, Abstract Data Types and Modula-2, Prentice Hall, Hemel Hempstead, 1992, pp. 389.
How to do object-oriented programming in Modula-2. Lots of good and experienced advice. Marvelous chapter on choosing names in programs. Two-thirds of the book is a case study of writing a text indexing program in Modula-2 in object-oriented style.

* HyperCard IIgs Script Language Guide: the HyperTalk Language, Addison-Wesley, Reading, Mass., 1990, c1991, pp. 401.
Authorless manual on HyperTalk. The thing you need around when programming in it. 100 pages of language features (messages, objects, values, expressions and control structures), 300 pages of manual pages for commands, functions and properties.

* Dan Shafer, The Complete Book of HyperTalk 2, Macintosh Inside Out, Addison-Wesley, Reading, Mass., 1991, pp. 444.
Earlier title: HyperTalk Programming (with Hayden Books). Excellent and enthusiastic text book on HyperText. No explicit exercises but plenty of case studies and what the author calls `hands-on exercises', in which the user is invited to try certain things. Introductory explanation of HyperCard. The text covers the full use of HyperTalk; it has a section on debugging.
     HyperTalk is object-oriented in that it has five built-in types (stacks, backgrounds, cards, buttons and fields) that behave as object types. They understand messages and have methods, but there is little in the way of inheritance.

* Nancy Stern, Robert A. Stern, Structured COBOL Programming, (6th edn), Wiley, New York, 1991, pp. 763.
Includes booklet The COBOL syntax reference guide (73 p.). Excellent and cheap.

* Gottfried Vossen, Data Models, Database Languages, and Database Management Systems, International Computer Science Series, Addison-Wesley, Workingham, England, 1991, pp. 590.
Treats DDL and DDM of Siemens UDS, IBM's IMS, SQL and user interfaces to them.

* Dean W. Gonzalez, Ada Programmer's Handbook, Benjamin/Cummings, Redwood City, Ca 94065, 1991, pp. ± 250.
The book consists of eight parts: a glossary of Ada terms (extensive but concise); six small example programs; a list of common errors with examples, both compile-time and run-time; syntax summary (alphabetical); syntax diagrams (alphabetical); extensive bibliography, not annotated; predefined packages; quick reference guide.

* Hans P. Zima, A constraint language and its interpreter, Computer Languages, vol. 11, #2, pp. 65-83. July 1991,
Describes a straightforward equation solver in detail. The equation solver can handle conditional expressions (but no inequalities, as far as I can see).

* ?. Ellis, Bjarne Stroustrup, The Annotated C++ Reference Manual, Addison-Wesley, Reading, Mass., 1990, pp. ???.
Includes the C++ name mangling algorithm.

* Michael Eisenberg, Programming in Scheme, (edited by Harold Abelson), MIT Press, Cambridge, Mass., 1990, pp. 304.
The book can be seen as a programming companion to Abelson and Sussman's book `Structure and Interpretation of Computer Programs'. It teaches programming at a slow pace, using PC Scheme as a vehicle. It may be intended for children and teenagers (though it does not say so), but even then it occasionally verges on the condescending. It may be symptomatic of the language that the library copy of the book which I saw had many pencil lines in it connecting open and close parentheses.

* M.F. Cowlinshaw, The REXX Language, Prentice Hall, Englewood Cliffs, NJ, 1990, pp. 203.
The language in all its ugliness.

* Roger Bailey, Functional Programming with HOPE, Ellis Horwood Series in Computers and their Applications, Ellis Horwood, New York, 1990, pp. 301.
This text book aims to teach good programming. It does so by teaching good functional programming and uses Hope as a vehicle. Although the proclaimed emphasis is on programming, Hope itself gets about equal time. The exercises are rather scholastic.

* W.S. Brainerd, C.H. Goldberg, J.C. Adams, Programmer's Guide to Fortran 90, McGraw-Hill, New York, NY, 1990, pp. 410.
Not available in the Netherlands; see Dutch translation.

* Lowell Jay Arthur, UNIX Shell Programming, (2nd Edn.), John Wiley, New York, 1990, pp. 272.
Consists of three parts: Shell for the novice, Shell programming for the user, and Shell programming for the power user. Treats the shell as a real programming language. Also treats paraphernalia like lex, make, etc. Some emphasis on system administration.

* Ray Swartz, UNIX applications programming: mastering the shell, Howard W. Sams & Co., Carmel, Ind., 1990, pp. 452.
Not in libraries in the Netherlands. (930507).

* Robert J. Bent, George C. Sethares, Basic -- An Introduction to Computer Programming, (4th Edn.), Brooks/Cole, Pacific Grove, Calif., pp. 384. 1990,
The book presents an elementary though useful cross-section of computing, from what a PC is to heapsort, all geared to Basic. The style is reassuring and the people in the photographs are obligingly multi-ethnic.

* Kazunori Ueda, Takashi Chikayama, Design of the kernel language for the parallel inference machine, Computer J., vol. 33, #6, pp. 494-500. 1990,
KL1 is the kernel language of the FGCS project; it is intended to allow logic programming on PIMs (Parallel Inference Machines).
     At first sight, KL1 seems Prolog-like, and it is introduced as such, but there are profound differences, the main one being that KL1 has no built-in resolution mechanism; it has unification of parameters, though. Several problems had to be solved to reach a form of Horn Clauses that would accommodate parallelism, synchronization, I/O and efficient implementation easily. KL1 clauses are protected by guards, which are in themselves goals; these goals in the guards are restricted to built-in predicates only. When a goal comes up for evaluation, all guards of all clauses of it are evaluated in parallel; the guards cannot instantiate variables, and if a guard needs the value of an uninstantiated variable, it blocks. If all goals in a guard succeed, the corresponding clause is available. If one or more guards succeed, one of the available clauses is chosen, and the goals in its body are evaluated in parallel; these goals can instantiate variables.
     The above assures that if an instantiation is made, it is never revoked. Output to other processes is done by making bindings visible to them (through shared variables) and input is done by accepting instantiation from outside. This design provides parallelism and synchronization, but robs the Horn Clauses of their search capability, since it precludes any form of backtracking. Consequently, KL1 is not a logic language in the normal sense of the word.
     To control and improve the efficiency, KL1 has a superimposed pragma language, the objects of which are the processes (goals being evaluated) described by the program. Processes can be manipulated (assigned to a processor; given a priority; etc.) singly or in groups. The latter are defined by the programmer and are called sho-ens. The pragmas do not affect the correctness and may be obeyed, delayed or ignored at the discretion of the OS. This separates program correctness from program optimization by parallelism.
     An instantiated variable is immutable, but to gain efficiency, KL1 has instructions to obtain a modified copy of a variable quickly. If no other process (= goal being evaluated) uses the variable, the variable is modified in situ, otherwise a copy is made.
     The paper describes the lines of reasoning that led to the design of KL1.

* Stephen G. Kochan, Patrick H. Wood, UNIX Shell Programming, (Rev. Edn.), Hayden Books, Carmel, Indiana 46032, 1990, pp. 490.
Slow-paced and very explicit treatment. The first 100 pages cover elementary UNIX commands, then come 200 pages about the shell proper, followed by material on the Korn shell. The book closes with summaries of the Bourne shell and the Korn shell, 50 pages each.

* Leo Geurts, Lambert Meertens, Steven Pemberton, The ABC Programmer's Handbook, Prentice-Hall, 1989, pp. ???.
Full details of ABC and the implementations, along with many example programs.

* P.H. Winston, B.K.P. Horn, LISP, (3rd Edn.), Addison-Wesley, Reading MA, 1989,
Includes classes, generic functions, constraint propagation, streams, delayed evaluation, backward chaining, etc, etc.

* C.J. Date, A Guide to the SQL Standard, (2nd Edn.), Addison-Wesley, Reading, Mass., 1989, pp. 228.
Good introduction to SQL.

* Leen Ammeraal, ANSI C, (in Dutch: ANSI C), Academic Service, Schoonhoven, 1989, pp. 244.
Straightforward description of ANSI C, no superfluous word in it.

* Raphael L. Levien, Io: a new programming notation, ACM SIGPLAN Notices, vol. 24, #12, pp. 24-31. Dec. 1989,
A very nifty crossbreed between HET and functional languages, with being derived from either.

* John D. Ramsdell, The Alonzo functional programming language, ACM SIGPLAN Notices, vol. 24, #9, Sept 1989, pp. 152-157.
A lazy parallel functional programming language derived from Scheme.

* M. Friendly, advanced LOGO -- a language for learning, Lawrence Erlbaum Assoc., Hillsdale, NJ., 1988, pp. ???.
Includes high-level applications like dampened springs.

* Bertrand Meyer, Object-Oriented Software Construction, Prentice Hall, New York, 1988, pp. 534.
Actually largely an Eiffel Manual.

* J. Heath, L. Welsh, Difficulties in parsing SGML, in ACM Conference on Document Processing Systems, Santa Fe, New Mexico, Dec. 5-9, 1988, New York, ACM, 1988, pp. 71-77.
After some laments on the technical incompetence displayed in designing standards, the authors, working at the National Bureau of Standards, explain how they constructed a parser for SGML as defined in ISO 8879, 1986 and what difficulties they encountered. Unfortuantely, none of this is described in sufficient detail to be evaluated. The parser is constructed by using lex exclusively, exploiting the fact that DTD are not (usually?) recursive; the system allows calls to other FSAs, however, inside the code of an FSA, without allowing recursion, it seems.
     The authors list a number of problems, without giving examples or further elucidation. Most seem to arise from a lack of familiarity with computer science and parsing on the part of the SGML designers. 1. SGML entity processing can not be implemented by C macro processing. True, since entities in SGML are trees and macros in C are strings. Doubtful. 2. Tag minimization complicates parsing. No explanation given, except the remark that tag minimization is different in $ ( ( A , B ) | B ) $ and $ ( A ? , B ) $. 3. CR is treated differently from LF. Bothersome, but this is not a parsing issue. 4. The &-connector is a nuisance. Agreed, but no explanation given. 5. Furthermore the authors claim that any parts of SGML that are not regular, are context-sensitive, i.e., there is no context-free layer.
     Summary: might have been meaningful, no, would no doubt have been meaningful, had the authors substantiated what they now claim antagonistically. It seems none of this has had any impact on the SGML definition.

* Thomas Cooper, Nancy Wogrin, Rule-based Programming with OPS5, Morgan Kaufmann Publ., San Mateo, Ca., 1988, pp. 350.
An OPS5 program has a workspace in which "Working Memory Elements" (WMEs) reside; WMEs are in essence structured values with a time stamp. The program consists of an unordered set of rules, "condition-action pairs". The OPS5 engine goes through a recognize-act cycle. Rule recognition consists of two steps, match and select. The match step matches all WMEs to all conditions, instantiating condition variables by unification, called "inter-element match"; this yields the active set, called "conflict set" here. The select steps select one rule to be performed, using conflict resolution if needed. Conflict resolution involves such criteria as the time stamps of the matched WMEs and the specificity (~ length) of the condition. Action include adding, modifying, removing and displaying WMEs, binding values to variables, calling external subroutines and halting the program.

* Jim van Keulen, Modula-2 -- een inleiding, (in Dutch: "Modula-2, an Introduction"), Academic Service, Schoonhoven, pp. 258. 1988,
No-nonsense introduction, teaching both elementary programming and Modula-2. Also introduces EBNF.

* Jacques Cohen, A view of the origins and development of Prolog, Commun. ACM, vol. 31, #1, Jan. 1988, pp. 26-36.
The author shows how Prolog arose as the combined result of 1. parsing and natural language processing (Colmerauer); and 2. theorem proving (Kowalski). W grammars also played an important role.

* R. Kent Dybvig, The Scheme Programming Language, Prentice-Hall, Englewood Cliffs, N.J., 1987, pp. 242.
Scheme is dialect of Lisp featuring static scoping, first-class (typed) procedures, objects and continuations. It still suffers from parenthitis. There is a function \*<extend_syntax\*> which allows a pattern matcher for new syntax to be introduced. Much of the language can be (is?) defined in this way.
     The book assumes knowledge of Lisp or at least of programming and list processing. It is a straightforward explanation of Scheme, for the practical programmer.

* Leo Brodie, Forth Inc., Starting Forth, (2nd Edn.), Prentice-Hall Software Series, Prentice-Hall, Englewood Cliffs, NJ, 1987, pp. 346.
Entertaining and very useful text book, though not academic level. A bit weak on exercises.

* R.J. Pooley, An Introduction to Programming in SIMULA, Computer Science Texts, Blackwell Scientific Publications, Oxford, 1987, pp. 333.
A steady-paced introduction focusing on the language rather than on simulation applications. Conforms to the 1986 SIMULA Standard. Quite palatable.

* Kevin P. Roddy, UNIX NROFF/TROFF: a user's guide, Holt, Rinehart and Winston, New York, 1987, pp. 362.
Disappointing in that it shows a lot of troff code but does not show the results; the results are only described.

* Åke Wikström, Functional Programming Using Standard ML, Prentice Hall, London, 1987, pp. 446.
Rather long-winded explanation of how to program in ML; the English is misleading in places.

* Yasunori Kimura, Takashi Chikayama, An abstract KL1 machine and its instruction set, in 1987 Symposium on Logic Programming, pp. 468-477. 1987,
KL1 is flat guarded Horn clauses, i.e., Prolog with a point of no return in each right hand side. The code before the point of no return, the guard, may contain built-in predicates only. In reducing the goal, the guards of all of its alternatives are reduced in parallel (OR parallelism). For all that succeed, the guarded code is reduced in parallel (AND parallelism). The paper describes an interpreter which is structured in such a way that parts of it can be easily implemented in hardware. It is similar to the Warren machine.

* Steven Pemberton, An alternative simple language and environment for PCs, IEEE Software, vol. 4, #1, Jan. 1987, pp. 56-64.
Plug for ABC.

* R. Nigel Horspool, C Programming in the Berkeley UNIX Environment, Prentice-Hall, Scarborough, Ont., 1986, pp. 303.
Readable, real-life and to the point.

* Rod Manis, Marc H. Meyer, The UNIX Shell Programming Language, Howard W. Sams, Indianapolis, IN., 1986, pp. 303.
Excellent book on shell programming, written by people who have been there. Many case studies, well explained. Could do with less obvious humor.

* Joan K. Hughes, PL/I Structured Programming, (3rd Edn.), John Wiley & Sons, New York, 1986, pp. 639.
Solid, well-seasoned text book on PL/I. Slowpaced but thorough; just what PL/I needs.

* Leon Sterling, Ehud Shapiro, The Art Of Prolog -- Advanced Programming Techniques, MIT Press, Cambridge, Mass., 1986, pp. 437.
Starting rather philosophically, it covers Prolog in breadth and depth. Very readable with many pertinent examples. Covers many Prolog idioms (difference lists, definite clause grammars, meta-interpreters, etc.). Points out that the occur check may add a factor N to the run-time complexity (if no special measures are taken).

* W.D. Burnham, A.R. Hall, Prolog Programming and Applications, Macmillan, London, 1985, pp. 114.
Example-oriented tutorial on Prolog, intended to serve as a stepping stone to Clocksin and Mellish. No mention of the occur check. No literature.

* Daniel Thalman, Modula-2 -- An Introduction, Springer-Verlag, Berlin, 1985, pp. 292.
Dry, straightforward text book. Good summaries for each chapter. The examples are often (too) obvious. Rather numerical.

* Niklaus Wirth, Programming in Modula-2, Springer-Verlag, Berlin, 1985, pp. 202.
Cumbersome and educationally inferior description of same.

* Ed Knepley, Robert Platt, Modula-2 Programming, Reston Publ., Reston, Virg., 1985, pp. 390.
Good introduction of considerable scope.

* Lee Brownston, Robert Farrell, Elaine Kant, Nancy Martin, Programming Expert Systems in OPS5, Addison-Wesley, Reading, Mass., 1985, pp. 471.
Thorough exposition of condition-action programming (called production systems here), its foundations and applicability. Course text on OPS5 with programming techniques and efficiency considerations. Full explanation of the Rete algorithm. Comparisons with other systems, including MYCIN and LOOPS.

* Walter A. Ettlin, Gregory Solberg, Microsoft Basic, Samsom Uitgeverij, Alphen a/d Rijn, 1985, pp. 408.
In Dutch.

* William W. Wadge, Edward A. Ashcroft, Lucid, the Dataflow Programming Language, Academic Press, London, 1985, pp. 310.
All variables in Lucid denote possibly infinite sequences of values; all definitions define filters on these sequences. There are no statements, there is no flow-of-control. I/O is done by seamlessly interfacing with UNIX filters (= pipes). Although the authors make an attempt to explain the difference between the data-flow model and functional programming, that text is not readily summarized.
     The authors defend Lucid and the data-flow paradigm in an entertaining way by classifying the critics under such headings as Cowboys, Mystics, Boffins, etc. A further piece of comic relief is that the Lucid OS is called LUNIX.
     The book starts with an algebraic foundation; sequences, iteration, recursion and nested iteration follow. Examples a large chapter on program transformations and one on further developments conclude the book.

* Alain Colmerauer, Prolog in 10 figures, Commun. ACM, vol. 28, #12, Dec. 1985, pp. 1296-1310.
A three-pages introduction followed by 10 annotated figures, leading the reader from expression trees to an infinity of rules on trees to generating permutations to solving cryptarithmetic puzzles.

* H. Pinxteren, J. Ringelberg, LOGO: een inleiding, Aula Pocket 740, Het Spectrum, Utrecht, 1984, pp. 192.
About the turtle control language LOGO, which can, by the way, be used for many other purposes.

* L. Ammeraal, De programmeertaal C, (in Dutch: The Programming Language C), Academic Service, Schoonhoven, 1984, pp. 108.
Straightforward description of ANSI C, no superfluous word in it.

* Ralph E. Griswold, Madge T. Griswold, The Icon Programming Language, Prentice-Hall, Englewood Cliffs, NJ, 1983, pp. 313.
Adequate tutorial on Icon, in four parts. Basics: control structure, expression evaluation, I/O. Advanced features: generators, string scanning, co-expressions. Programming techniques: high-level string processing, list processing. Sample programs: large integers, symbolic algebra and grammar handling.

* Doug Cooper, Michael Clancy, Oh! Pascal!, W.W. Norton & Co., New York, NY 10110, pp. 476. 1982,
Didactically very strong introduction to computer science, problem solving, programming and Pascal. Charming and juicy, without being slick. Very practical, lots of advice on debugging and how to avoid it ("antidebugging"), self-tests, jargon glossary. Data structures, linked lists, trees, ADTs. Erudite without being obvious about it.

* James R. McGraw, The VAL language: description and analysis, ACM TOPLAS, vol. 4, #1, pp. 44-82. Jan. 1982,
VAL is a side effect free language, based on expressions and non-recursive functions. Normally the language is single-definition, but in a fairly complex construct redefinition is allowed to handle iteration. Its main features are explained using a single example, quad integration.

* Donald E. Knuth, The remaining trouble spots in ALGOL 60, Commun. ACM, vol. 10, #10, pp. 611-618. Oct. 1967,
Twelve extensively described trouble spots plus proposed solutions. (Reprinted in E. Horowitz, Programming Languages: A Grand Tour (Computer Science Press, 1982), 61-68.)

* Ralph E. Griswold, David R. Hanson, An alternative to the use of patterns in string matching, ACM Trans. Programming Languages and Systems, vol. 2, #2, pp. 153-172. April 1980,
The basics of Icon. Many literature references to pattern matching.

* David H.D. Warren, Logic programming and compiler writing, Softw. Pract. Exper., vol. 10, Feb. 1980, pp. 97-125.
An introduction to logic programming, using a small compiler construction project as the running example.

* William A. Wulf, Ralph L. London, Mary Shaw, An introduction to the construction and verification of Alphard programs, IEEE Trans. Software Engineering, vol. SE-2, #4, pp. 253-265. Dec. 1976,
Provides an introduction to Alphard and gives a calculus, based on Hoare's pre- and post-conditions, to prove program correctness in Alphard.

* C.A. King, A graph-theoretical programming language, in Graph Theory and Computing, ed. by Ronald C. Read, Academic Press, New York, 1972, pp. 63-75.
[ GTPL, a FORTRAN extended with graph commands: I/O, canonical labelling, etc. ]

* F.L. Bauer, H. Wössner, The ``Plankalkül'' of Konrad Zuse: a forerunner of today's programming languages, Commun. ACM, vol. 15, #7, pp. 678-685. July 1972,
Introduction to Plankalkül, with equivalents in Algol 68. Unfortunately, quotes and facsimiles from the original were not translated.

* Harry Katzan Jr., APL User's Guide, Computer Science Series, Van Nostrand Reinhold, New York, 1971, pp. 126.
APL user's guide.

* Harry Katzan Jr., APL Programming and Computer Techniques, Computer Science Series, Van Nostrand Reinhold, New York, 1970, pp. 329.
True to the title, it explains computers starting from the CPU and keyboard upward, then covers APL and algorithms, continues with operating systems and ends with FORTRAN, which gets 15 pages. Many exercises, many APL programs.

* W.A. Zaremba, On ALGOL I/O conventions, Commun. ACM, vol. 8, #3, pp. 167-169. March 1965,
Some comments on and additions to Knuth's et al. proposal for input-output in ALGOL 60.

* D.E. Knuth, L.L. Bumgarner, D.E. Hamilton, P.Z. Ingerman, M.P. Lietzke, J.N. Merner, D.T. Ross, A proposal for input-output conventions in ALGOL 60, Commun. ACM, vol. 7, #5, pp. 273-283. May 1964,
Based on C-like formats (Section A), the syntax of which is given, and on a set of I/O procedures (Section B), some of which like C printf(), but defined generically, to avoid the varargs problem. Lists are handled by wrapping them into list procedures (Section B.4),which are then passed to the I/O procedures. No earlier reference to list procedures is given, so this may be the original, and for all I know only, reference.

* Kenneth E. Iverson, A Programming Language, John Wiley and Sons, New York, 1962, pp. 286.
A mathematical description of APL and its application to many problems like searching and sorting, somewhat Knuth-like.

* Daniel D. MacCracken, A Guide to ALGOL Programming, Burroughs Bulletin 5000-21015, John Wiley, New York, 1962, pp. 106.
A simple course in ALGOL programming, somewhat tailored to Burroughs ALGOL, for example in the input-output section. No higher-order functions, though Jensen's device is discussed. Many examples from physics (Stefan-Boltzmann equation, luminosity).

* Jean E. Sammet, Basic Elements of Cobol 61, Commun. ACM, vol. 5, 1962, pp. ???.
Fair description of same.

* E.L. Willey, A. d'Agapeyeff, Marion Tribe, B.J. Gibbens, Michelle Clark, Some commercial Autocodes -- A comparative study, A.P.I.C. Studies in Data Processing #1, Academic Press, London, 1961, pp. 53.
Compares eight very early programming languages of the autocode type and higher, in tables with check marks for each feature present, e.g. whether "formulae" are allowed as operands, and with sample forms for the various constructs, e.g., for the form a + b = b (i.e. b := a + b).
     The eight languages are: FLOWMATIC (Remington Rand), IBM COMMERCIAL TRANSLATOR (IBM), COBOL (Special Committee), FACT (Honeywell), CODEL (ICT), ELLIOTT'S (Elliott Bros.), NEBULA (Ferranti), and SEAL (Standard Telephones & Cables).