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):
- Chapter ?: The LLVM language
- Chapter ?: RPython
- Chapter ?: The Java bytecode (JVM) language
- Chapter ?: CIL
- Chapter ?: Nock
- Chapter ?: web browser intermediate target languages
- Chapter ?: other intermediate target languages
- Chapter ?: other intermediate target languages designed for implementing a single high-level language
- Chapter ?: other intermediate target languages designed for implementing a single high-level language, part 2
- Chapter ?: other intermediate target languages designed for implementing a single high-level language, part 3
- Chapter ?: other intermediate target languages designed for implementing a single high-level language, part 4
- Chapter ?: domain-specific target languages
- Chapter ?: Assembly language principals
- Chapter ?: Assembly language minimalistic ISAs
- Chapter ?: Assembly language frequently used instructions
- Chapter ?: The ARM ISA
- Chapter ?: The x86 ISA
- Chapter ?: The MIPS and DLX, etc, ISAs
- Chapter ?: The RISC-V ISA
- Chapter ?: The Motorola 68000 and related processors
- Chapter ?: The Mos 6502
- Chapter ?: PowerPC
- Chapter ?: Sparc
- Chapter ?: Z80
- Chapter ?: The PDP-8 and PDP-11 ISAs
- Chapter ?: The PIC and AVR MCU ISAs
- Chapter ?: The MSP430 MCU ISA
- Chapter ?: Soft core ISA
- Chapter ?: Parallax Propeller multicore MCU ISA and SPIN bytecode
- Chapter ?: ISA comparisons
- Chapter ?: Other CPU Instruction Set Architectures
- Chapter ?: Stack Machines
- Chapter ?: Languages for automated programming
- Chapter 28: Graphics co-processor languages (especially GPGPU)
- Chapter ?: Encoding issues
- Chapter ?: Target Languages Concordance: A cross-platform concordance of instructions from seven intermediate- or assembly- language architectures: RISC-V, WASM, LLVM, ARM Cortex M0, JVM, LuaJIT?2, CLI
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 VII: Usage patterns, idioms, and best practices:
Part VII: Formal theoretical 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