Lecture Notes: Theory (and Practice) of Programming Languages

COMP 371/471 | Department of Computer Science | Loyola University Chicago

You have reached the home of the Programming Languages course (COMP 371/471) in the Computer Science Department of Loyola University Chicago.

Welcome! Willkumme! ¡Bienvenidos/as! Benvenuti/e!

Warning

These notes are still being written, so expect a few rough edges. But we’re getting closer!

Build Status

This book is written using the Python Sphinx documentation tool. It automatically builds and deploys using GitHub Actions (a continuous integration system). All commits trigger a rebuild of the book and, if successful, a deployment to GitHub pages.

Book Web Site

lucproglangcourse.github.io

Book PDF (Latest Relase)

github.com/lucproglangcourse/lucproglangcourse.github.io/releases/latest/download/proglang.pdf

Book Source Code

github.com/lucproglangcourse/lucproglangcourse.github.io

How to Contribute

Your contributions are highly welcome! Please submit issues and pull requests.

Contents

Todo

Ensure proper structural mapping from Sphinx to LaTeX

• 1. Overview
  • 1.1. Course Information
  • 1.2. Motivation
  • 1.3. Key learning outcomes
  • 1.4. Some starting points for functional programming
  • 1.5. Course outline
  • 1.6. Bloom’s taxonomy
• 2. Context and Background
  • 2.1. Software requirements
  • 2.2. Overview of a lightweight development process
  • 2.3. Software design principles and patterns
  • 2.4. Programming language history and paradigms
  • 2.5. Popularity indices and performance comparisons
• 3. The Imperative Programming Paradigm
  • 3.1. Core elements
  • 3.2. Solving problems using built-in types and behaviors
  • 3.3. Options for running Scala code
  • 3.4. Techniques for testing Scala code
  • 3.5. The role of command-line applications
  • 3.6. The role of logging
  • 3.7. The importance of constant-space complexity
  • 3.8. Making command-line applications testable
• 4. The Object-Oriented Programming Paradigm
  • 4.1. Core elements
  • 4.2. Making command-line applications testable
  • 4.3. Defining domain models in object-oriented languages
  • 4.4. Object-oriented Scala as a “better Java”
  • 4.5. Modularity and dependency injection
• 5. The Functional Programming Paradigm
  • 5.1. Core Elements
  • 5.2. Solving problems using built-in types and behaviors
  • 5.3. Defining algebraic data types
  • 5.4. Behaviors on algebraic data types
  • 5.5. A closer look at predefined behaviors on lists
  • 5.6. Separation of concerns at the type level
  • 5.7. Other useful abstractions
  • 5.8. References
• 6. Program Representation and Interpretation
  • 6.1. Programming language toolchains
  • 6.2. Compiler front-end concepts and techniques
  • 6.3. Programming language semantics
  • 6.4. Case study: a simple imperative language
  • 6.5. Case study: a simple imperative language with records
  • 6.6. Type systems
  • 6.7. Domain-specific languages
• 7. The Concurrent Programming Paradigm
  • 7.1. Core Elements
  • 7.2. Concurrency vs. Parallelism
  • 7.3. Motivation
  • 7.4. Activity terminology and concerns
  • 7.5. Thread safety
  • 7.6. Dealing with shared state
  • 7.7. (Conflicting) design forces
  • 7.8. Specific concurrency mechanisms
  • 7.9. References: concurrent and asynchronous computing
• 8. The Logic Programming Paradigm
  • 8.1. Core Elements
  • 8.2. Hello World in Prolog
  • 8.3. Basic Facts and Rules Example
  • 8.4. 8-Queens Example in Prolog
  • 8.5. Performance, nondeterminism, and the cut operator
• 9. Other Important Programming Paradigms
  • 9.1. Declarative Programming
  • 9.2. Reactive Programming
  • 9.3. Aspect-Oriented Programming
  • 9.4. Dataflow Programming
  • 9.5. Other Paradigms
• 10. Summary
• 11. Appendix: Programming Language Design Principles
• 12. Appendix: Resources
  • 12.1. Key resources
  • 12.2. Code examples
  • 12.3. Recommended/supplementary texts
  • 12.4. Additional texts on Scala
  • 12.5. Online Scala resources
  • 12.6. Resources on program representation and interpretation
  • 12.7. Other resources
• 13. Appendix: Course Software
  • 13.1. Cloud-based development environment
  • 13.2. Locally installed development environment
  • 13.3. sbt optional plugins
  • 13.4. GitHub
  • 13.5. Remote participation
• 14. Appendix: Course Syllabi
  • 14.1. Course: COMP 371/471 Programming Languages
  • 14.2. Section: 001 Fall 2025
  • 14.3. Section: 001 Fall 2024
  • 14.4. Section: 001 Fall 2023
  • 14.5. Section: 001 Fall 2022
  • 14.6. Section: 001 Fall 2021
  • 14.7. Sections: 001/002 Fall 2020
  • 14.8. Section: 001 Fall 2019
  • 14.9. Section: 001 Fall 2018
  • 14.10. Section: 001 Spring 2018
  • 14.11. Section: 001 Spring 2017
  • 14.12. Detailed Course Outline
  • 14.13. Key Resources
• 15. Appendix: TODO

Indices and tables

• Index

• Search Page

Todo

add sample projects, activities, tests, and (tiered) master list for presentations

Todo

add stuff from https://trello.com/c/kAMGZ4uf/28-add-in-next-iteration

Note

AI Disclosure: This text contains a mix of original writing and programming with strategic use of ChatGPT via intentional prompting. Some examples will be available in our repository with an appropriate build configurations and tests. We may also make some prompts and analyses available, similar to what my colleagues have done for their recent ongoing study of ChatGPT and Systems Programming. See https://doi.org/10.6084/m9.figshare.22257274.