I've mentioned this sale already in the Shared Source CLI Essentials discussion, but here are some more words on each of the books with significant programming-language-related stuff. I'm posting this here because if they don't go by Monday, I'll probably have to cart them all off to a used bookstore, and I'd rather if you people got them instead.|
Ashcroft et al, Multidimensional Programming.
Covers the modern version of Lucid, a dataflow language with intensional semantics. It now allows defining new problem-specific dimensions, where the original languages was intensional only over the time dimension. The last chapter considers how these ideas can apply to things like logic programming and spreadsheets.
Baader and Nipkow, Term Rewriting and All That.
The mathematics of term rewriting, with code in ML for all the main algorithms.
Alan Bundy, The Computer Modeling of Mathematical Reasoning.
20-year-old book on theorem proving, with a couple chapters on mathematical invention. I think this sort of thing will get more important as our languages and programming environments get smarter.
William Clocksin, Clause and Effect: Prolog Programming for the Working Programmer.
Basic practical introduction to logic programming. I took the FFT example in my partial evaluation article from it.
Clocksin and Mellish, Programming in Prolog.
The original introduction to Prolog, that also served as a de facto language standard of a sort.
Conlon, Programming in PARLOG.
Intro to concurrent logic programming and the PARLOG language, a close relative of GHC and Concurrent Prolog.
Allen Cypher (editor), Watch What I Do: Programming by Demonstration.
Papers on end-user programming by concrete manipulation.
Darlington and Dietrich (editors), Declarative Programming Sasbachwalden 1991.
Workshop papers. My favorites were a couple by Darlington on integrated constraint/functional/logic languages.
Ehrig et al (editors), Mathematical foundations of software development (TAPSOFT Proceedings 1985 volumes 1 & 2).
Includes a successor paper from Backus to his Turing award lecture, among others.
Filman and Friedman, Coordinated Computing: Tools and Techniques for Distributed Software.
Interesting early survey of models, languages, and heuristics for concurrent and distributed systems.
Richard P. Gabriel, Patterns of Software.
Essays on languages, patterns, etc. The last part of the book chronicles the rise and downfall of Lucid, a Lisp startup in the 80s.
Daniel Gajski (editor), Silicon Compilation.
Collection of papers on generating hardware from specifications at various levels of abstraction.
Gelernter and Jagganathan, Programming Linguistics.
Unusual textbook on programming languages that doesn't shy from taking stands on aesthetics and elegance. Tries to get at underlying principles and historical patterns.
Genesereth and Nilsson, Logical Foundations of Artificial Intelligence.
Takes the point of view that the important language for intelligent programs is (various sorts of) formal logic.
David Gries, Compiler Construction for Digital Computers.
Very early compiler textbook.
Griswold and Griswold, The Implementation of the Icon Programming Language.
This goes into the nitty-gritty of a real VM-based language implementation.
Daniel Hillis, The Connection Machine.
Describes a very cool architecture, with a chapter on CM-Lisp. The last chapter argues that computer science should be more like physics, and is bound to get that way as our machines become more powerful.
C. A. R. Hoare (editor), Developments in Concurrency and Communication.
Several papers on specifying/generating systems with CSP-based languages. Includes two papers by Hoare.
Neil D. Jones, Computability and Complexity: From a Programming Perspective.
Textbook on the theory of computation but with an influence from programming language theory -- using things like partial evaluation and a Lisp-like language to make ideas clearer.
Randy M. Kaplan, Constructing Language Processors For Little Languages.
A worthwhile idea poorly executed. Has anyone written a good book on DSLs? I've kept this one around just to reassure myself that I could get a book published too, if I worked at it.
Melvin Klerer, Design of Very High-level Computer Languages: A User-Oriented Approach, 2nd edition.
DSLs for engineers and such. Takes the curious position that familiar 2d mathematical notation is more important than semantics.
Robert Kowalski, Logic for Problem Solving.
Classic on logic programming. I'm afraid I haven't read it.
Knuth and Levy, The CWEB System of Structured Documentation.
The implementation of a literate programming system. At one point Knuth works out a DSL for certain processes on the parse trees, using typesetting to make that little language look nice, but then he goes and implements the program by hand! The DSL was just there for documentation.
Lindholm and Yellin, The Java Virtual Machine Specification.
Liskov and Guttag, Abstraction and Specification in Program Development.
Covers the CLU language, and it's one of my favorite books on program development.
Marriott and Stuckey, Programming with Constraints: An Introduction.
Modern book on constraint languages.
Francis McCabe, Logic and Objects.
A rather elegant object-oriented Prolog.
Bonnie Nardi, A Small Matter of Programming.
Anthropological studies of end-user programming systems. Makes the excellent point that there are lots of DSLs in everyday life: things like knitting patterns, baseball scoresheets, etc.
Frank Pagan, Partial Computation and the Construction of Language Processors.
Basic introduction to writing compilers, emulators, translators, and so on by doing partial evaluation by hand.
Richard E. Pattis, Karel the Robot: A Gentle Introduction to the Art of Programming.
A small educational language where your programs drive a robot around the screen.
John Reppy, Concurrent Programming in ML.
The CML language with applications and theory.
Reps and Teitelbaum, The Synthesizer Generator: A System for Constructing Language-Based Editors.
The idea is to plug in a grammar and get a language-specific editor that understands the parse trees. Built around incremental evaluation of attribute grammars.
Stasko et al (editors), Software Visualization: Programming as a Multimedia Experience.
Includes chapters on specifying visualizations, another on animating Prolog execution, others worth reading if you're thinking about getting your programming language to animate its programs.
Toffoli and Margolus, Cellular Automata Machines.
This is interesting as a model of computation that's more physical than our usual languages. You program the hardware with a Forth-based DSL.
J. van Leeuwen (editor), Handbook of Theoretical Computer Science, Volume B: Formal Models and Semantics.
Articles on lambda calculus, type systems, etc. etc.
van Wijngaarden et al, Revised Report on the Algorithmic Language Algol 68.
Classic language specification in all its insular glory.
Ward and Halstead, Computation Structures.
Not much explicit programming-language content, but I like how it vaults through a whole series of levels of abstraction and encourages you not to take for granted the levels you're given.
Winston and Brown (editors), Artificial Intelligence: An MIT Perspective. Volumes 1 and 2.
Winston and Shellard (editors), Artificial Intelligence at MIT: Expanding Frontiers, Volume 1.
Chapters on AMORD (a DSL for forward-chaining logic), the Programmer's Apprentice, the MIT Lisp Machine, Guy Steele's RABBIT Scheme compiler, Hewitt's "Control Structures as Patterns of Passing Messages", McAllester's ONTIC (mentioned in LtU discussion recently), Tom Knight's "An Architecture for Mostly Functional Languages", others.
Woodcock and Davies, Using Z: Specification, Refinement, and Proof.
Practical intro to a program specification language.