Bayle Shanks's website: proj-plbook-plContents

Please note that these are only notes towards two books that will probably never be finished. The "books" are only about 1% there. Perhaps these notes will make interesting reading in the meantime. -- bayle

Volume I: An Overview of Programming Languages

This is a very short-length book (~25 pages?) for programmers who just want to know (a) what the major programming languages are, what they are good for, and which ones to learn; (b) to learn the basic terminology that programming language afficianados use when comparing languages (eg 'parametric polymorphism') so that they can follow discussions about languages, and (c) to learn the other basic terminology used by programming language designers and implementers (eg 'lexer', 'abstract syntax tree'). Since the reader probably already knows half of this, it is broken into bite-sized chunks so that you can easily skip the stuff you know. This volume assumes that the reader already knows quite a bit about programming.

The target audience is readers who already have a fair bit of programming experience; you should know a couple of languages already. If you don't know things like what a compiler is, or what static vs. dynamic typing is, then this book is probably too advanced.

Contents:

History and families of programming languages
What's out there and what should I learn? An overview of major programming languages
- Favorites
- (see below)
- Aside: Subturing and related languages; Target languages/ILs
A brief catalog of some programming language constructs and features
Concurrency
Usage patterns, idioms, and best practices
Formal theoretical stuff
Type systems
Programming language implementation

Volume II: Programming Languages: a survey

This is a more detailed survey of programming languages, constructs found in programming languages, and related ideas. Despite the catalog-like character of some of its parts, it is not intended to be a reference work; it is intended to be read straight through (assuming i ever compile these scattered notes into something readable, of course; the notes are currently way too long to be read straight through; mb i should break out the details into a Volume III). This volume assumes that the reader already knows everything in Volume I: An Overview of Programming Languages.

Note: when i quote other people's opinions, often i quote the part in which they give a criticism of a language while omitting the context just before that where they said something to the effect of "Language X is my favorite language but...". This is because my goal is to make lists of specific pros and cons.

Contents:

Preface and Introduction

Part I: The design of programming languages:

Part II: A catalog of general-purpose programming languages:

Part III: A catalog of subturing programming languages, and turinggrade languages that compete with them:

Part IV: A catalog of target languages (ILs; intermediate languages):

Part V: A catalog of programming language constructs and features:

contains: data, OOP, extensible data, evaluation strategy (call-bys), operations, extensible operations, modules and encapsulation, linked data, managing state, managing state: scoping, team programming, misc, runtime features, std lib, interop,
Chapter 24: Syntax
Chapter ?: Control
Chapter ?: Looping
Chapter ?: Data
Chapter ?: Expressions, Functions, Evaluation strategy
Chapter ?: Operators
Chapter ?: Error handling and safety
Chapter ?: Numbers
Chapter ?: Strings
Chapter ?: Modules
Chapter ?: Metaprogramming
- contains: hacking the call stack, hacking the ENV, operations, hacking classes, syntax, eval (todo generalize), misc
Chapter ?: Metaprogramming: macros, fexprs, etc
Chapter ?: security features
Chapter ?: Low level
Chapter ?: Object-orientation
Chapter ?: Alternative paradigms motivated by physics
Chapter ?: Misc constructs
Chapter ?: Standard libraries
Chapter ?: Other features

Part VI: A catalog of constructs and features relating to concurrency and distributed computing: includes many misc concurrency notes that need to be organized into chapters

part 2 more misc concurrency notes that need to be organized into chapters
part 3 more misc concurrency notes that need to be organized into chapters
Introduction to concurrency
Coarse-Grained Processes
Fine-Grained Processes
Message Passing
Process Calculi
Sequencing around communication
Models of concurrent time
Shared memory
Consensus
Distributed systems
Concurrency in Electronics
Safety
Languages And Libraries
Links
notes and todos

Part VII: Usage patterns, idioms, and best practices:

contains: patterns, types of coding tasks
Chapter ?: Language-specific idioms and practices

Part VII: Formal theoretical stuff:

Chapter ?: CS theory 101
Chapter ?: Models of computation (Turing-equivalent systems) (also, models of concurrent computation)
Chapter ?: Sub-Turing models of computation
Chapter ?: Halting
Chapter ?: Semantics
Chapter ?: Misc formal stuff

Part IX: Type systems:

Part X: Implementation:

contains: the general pipeline, modularity, concurrency implementation, efficiency, Normal forms, Performance optimizations, etc
Chapter ?: Parsing (and lexing)
Chapter ?: targets, IRs, VMs and runtimes
Chapter ?: Control
Chapter ?: internal representations
Chapter ?: arithmetic
Chapter ?: LLVM
Chapter ?: PyPy (seen as a toolkit for creating programming languages)
Chapter ?: JVM
Chapter ?: CLR
Chapter ?: Other target/IR/VM/runtime systems for language creation
Chapter ?: Interop
Chapter ?: Backend
Chapter ?: Concurrency
Chapter ?: Administrative Automation (contains: garbage collection, greenthreads, TCO and strictness analysis)
Chapter ?: Performance and Optimization
Chapter ?: Tradeoffs
- contains: Constraints that performance considerations of the language and the toolchain impose on language design
Chapter ?: Undefined Behavior
Chapter ?: Programming language implementation case studies
Chapter ?: Programming language implementation tools
Chapter ?: Programming tooling case studies

(which part should this be in?) Chapter ?: Natural languages

Part XI: Random thoughts and ideas for the future of programming languages:

Part XII: Links and external resources:

todos

note somewhere that much of the 'opinions' section of the parts describing individual languages are designed to collect instances of tradeoffs or of things that could be approved; sometimes there might be a long blog post having various positive things to say about a language, but the only quote I take is one or two minor complaints. This makes more sense if you remember that although one of our goals here is to get a sense for how much people like each language and why, another goal is to collect notes on the consequences of various small choices when designing a programming language.

CategoryBookDraft